9370985666

Committed 04 Jun 2024 04:44PM UTC coverage: 69.08% (+0.9%) from 68.144%

Build # 9370985666

Build Type

Pull #215

github

Committed by

web-flow

Commit Message

Merge c2bdeb2ba into 48e78e3e4

Pull Request Pull Request #215: feat: Backup and Restore

Run Details

1079 of 1748 branches covered (61.73%)

Branch coverage included in aggregate %.

198 of 244 new or added lines in 24 files covered. (81.15%)

2 existing lines in 1 file now uncovered.

2270 of 3100 relevant lines covered (73.23%)

18.22 hits per line

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

51.38

/src/edge-agent/Agent.Credentials.ts

import { base64 } from "multiformats/bases/base64";

import {
  AgentError,
  Apollo,
  AttachmentBase64,
  AttachmentDescriptor,
  Castor,
  Credential,
  CredentialType,
  CredentialIssueOptions,
  Curve,
  DID,
  KeyProperties,
  KeyTypes,
  Seed,
  Message,
  Pluto,
  Pollux,
  CredentialMetadata,
  PresentationOptions,
  Mercury,
  PresentationDefinitionRequest,
  PresentationClaims,
  AttachmentFormats,
  PolluxError,
} from "../domain";

import { AnonCredsCredential } from "../pollux/models/AnonCredsVerifiableCredential";
import { JWTCredential } from "../pollux/models/JWTVerifiableCredential";
import { PresentationRequest } from "../pollux/models/PresentationRequest";

import { OfferCredential } from "./protocols/issueCredential/OfferCredential";
import { createRequestCredentialBody, RequestCredential } from "./protocols/issueCredential/RequestCredential";
import { IssueCredential } from "./protocols/issueCredential/IssueCredential";
import { Presentation } from "./protocols/proofPresentation/Presentation";
import { RequestPresentation } from "./protocols/proofPresentation/RequestPresentation";

import { AgentCredentials as AgentCredentialsClass, AgentDIDHigherFunctions } from "./types";
import { PrismKeyPathIndexTask } from "./Agent.PrismKeyPathIndexTask";
import { uuid } from "@stablelib/uuid";
import { ProtocolType } from "./protocols/ProtocolTypes";
import { validatePresentationClaims } from "../pollux/utils/claims";

export class AgentCredentials implements AgentCredentialsClass {
  /**
   * Creates an instance of AgentCredentials.
   *
   * @constructor
   * @param {Apollo} apollo
   * @param {Castor} castor
   * @param {Pluto} pluto
   * @param {Pollux} pollux
   * @param {Seed} seed
   */
  constructor(
    protected apollo: Apollo,
    protected castor: Castor,
    protected pluto: Pluto,
    protected pollux: Pollux,
    protected seed: Seed,
    protected mercury: Mercury,
    protected agentDIDHigherFunctions: AgentDIDHigherFunctions
  ) {}


  private createPresentationDefinitionRequest<Type extends CredentialType = CredentialType.JWT>(
    type: Type,
    definition: PresentationDefinitionRequest<Type>,
    from: DID,
    to: DID
  ) {
    const attachmentFormat = type === CredentialType.JWT ?
      AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS :
      AttachmentFormats.ANONCREDS_PROOF_REQUEST;

    return new RequestPresentation(
      {
        proofTypes: [],
      },
      [
        AttachmentDescriptor.build(
          definition,
          uuid(),
          'application/json',
          undefined,
          attachmentFormat
        )
      ],
      from,
      to,
      uuid()
    );
  }

  async initiatePresentationRequest(
    type: CredentialType,
    toDID: DID,
    claims: PresentationClaims<CredentialType>
  ): Promise<RequestPresentation> {
    const didDocument = await this.castor.resolveDID(toDID.toString());
    const newPeerDID = await this.agentDIDHigherFunctions.createNewPeerDID(
      didDocument.services,
      true
    );

    if (type === CredentialType.AnonCreds) {
      if (!validatePresentationClaims(claims, CredentialType.AnonCreds)) {
        throw new PolluxError.InvalidPresentationDefinitionError("Anoncreds Claims are invalid");
      }

      const presentationDefinitionRequest = await this.pollux.createPresentationDefinitionRequest(
        type,
        claims,
        new PresentationOptions({}, CredentialType.AnonCreds)
      );

      return this.createPresentationDefinitionRequest<CredentialType.AnonCreds>(
        type,
        presentationDefinitionRequest,
        newPeerDID,
        toDID
      );
    }

    if (type === CredentialType.JWT) {
      if (!validatePresentationClaims(claims, CredentialType.JWT)) {
        throw new PolluxError.InvalidPresentationDefinitionError("JWT Claims are invalid");
      }
      const presentationDefinitionRequest = await this.pollux.createPresentationDefinitionRequest<CredentialType.JWT>(
        type,
        claims,
        new PresentationOptions({
          jwt: {
            jwtAlg: ['ES256K']
          },
          challenge: "Sign this text " + uuid(),
          domain: 'N/A'
        })
      );
      return this.createPresentationDefinitionRequest<CredentialType.JWT>(
        type,
        presentationDefinitionRequest,
        newPeerDID,
        toDID
      );
    }

    throw new PolluxError.CredentialTypeNotSupported();
  }

  async verifiableCredentials(): Promise<Credential[]> {
    return await this.pluto.getAllCredentials();
  }

  /**
   * Extract the verifiableCredential object from the Issue credential message asyncronously
   *
   * @async
   * @param {IssueCredential} message
   * @returns {Promise<VerifiableCredential>}
   */
  async processIssuedCredentialMessage(
    issueCredential: IssueCredential
  ): Promise<Credential> {
    const credentialType = this.pollux.extractCredentialFormatFromMessage(
      issueCredential.makeMessage()
    );
    const attachment = issueCredential.attachments.at(0)?.data;

    if (!attachment) {
      throw new Error("No attachment");
    }

    const credData = base64.baseDecode((attachment as AttachmentBase64).base64);

    const parseOpts: CredentialIssueOptions = {
      type: credentialType,
    };

    if (credentialType === CredentialType.AnonCreds) {
      const linkSecret = await this.pluto.getLinkSecret();

      parseOpts.linkSecret = linkSecret?.secret;

      const credentialMetadata = await this.pluto.getCredentialMetadata(
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        issueCredential.thid!
      );

      if (!credentialMetadata || !credentialMetadata.isType(CredentialType.AnonCreds)) {
        throw new Error("Invalid credential Metadata");
      }

      parseOpts.credentialMetadata = credentialMetadata.toJSON();
    }

    const credential = await this.pollux.parseCredential(credData, parseOpts);

    await this.pluto.storeCredential(credential);

    return credential;
  }

  /**
   * Asyncronously prepare a request credential message from a valid offerCredential for now supporting w3c verifiable credentials offers.
   *
   * @async
   * @param {OfferCredential} offer
   * @returns {Promise<RequestCredential>}
   */
  async prepareRequestCredentialWithIssuer(
    offer: OfferCredential
  ): Promise<RequestCredential> {
    const message = offer.makeMessage();
    const credentialType =
      this.pollux.extractCredentialFormatFromMessage(message);

    let credRequestBuffer: string;

    if (credentialType === CredentialType.AnonCreds) {
      const linkSecret = await this.pluto.getLinkSecret();
      if (!linkSecret) {
        throw new Error("No linkSecret available.");
      }

      const [credentialRequest, credentialRequestMetadata] =
        await this.pollux.processAnonCredsCredential(message, { linkSecret });

      credRequestBuffer = JSON.stringify(credentialRequest);

      // TODO can we fallback here? would need another identifier
      const metaname = offer.thid;

      if (!metaname) {
        throw new Error("Missing offer.thid");
      }

      const metadata = new CredentialMetadata(CredentialType.AnonCreds, metaname, credentialRequestMetadata);

      await this.pluto.storeCredentialMetadata(metadata);
    } else if (credentialType === CredentialType.JWT) {
      // ?? duplicated Agent.DIDHigherFunctions.createNewPrismDID
      const getIndexTask = new PrismKeyPathIndexTask(this.pluto);
      const keyIndex = await getIndexTask.run();
      const privateKey = await this.apollo.createPrivateKey({
        [KeyProperties.curve]: Curve.SECP256K1,
        [KeyProperties.index]: keyIndex,
        [KeyProperties.type]: KeyTypes.EC,
        [KeyProperties.seed]: this.seed.value,
      });

      const did = await this.castor.createPrismDID(privateKey.publicKey());

      await this.pluto.storeDID(did, privateKey);

      credRequestBuffer = await this.pollux.processJWTCredential(message, {
        did: did,
        keyPair: {
          curve: Curve.SECP256K1,
          privateKey: privateKey,
          publicKey: privateKey.publicKey(),
        },
      });
    } else {
      throw new AgentError.InvalidCredentialFormats();
    }

    const requestCredentialBody = createRequestCredentialBody(
      offer.body.formats,
      offer.body.goalCode,
      offer.body.comment
    );

    // TODO: remove assertions
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    const from = offer.to!;
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    const to = offer.from!;
    const thid = offer.thid;

    const credentialFormat =
      credentialType === CredentialType.AnonCreds
        ? AttachmentFormats.ANONCREDS_REQUEST
        : credentialType === CredentialType.JWT
          ? CredentialType.JWT
          : CredentialType.Unknown;

    const attachments = [
      new AttachmentDescriptor(
        {
          base64: base64.baseEncode(Buffer.from(credRequestBuffer)),
        },
        credentialFormat,
        undefined,
        undefined,
        // TODO: confirm what is the format that backend expects us to send AnonCreds VS JWT
        credentialFormat
      ),
    ];

    const requestCredential = new RequestCredential(
      requestCredentialBody,
      attachments,
      from,
      to,
      thid
    );

    attachments.forEach((attachment) => {
      requestCredential.body.formats.push({
        attach_id: attachment.id,
        format: credentialFormat,
      });
    });

    return requestCredential;
  }

  private async getPresentationDefinitionByThid<Type extends CredentialType = CredentialType.JWT>(thid: string): Promise<PresentationDefinitionRequest<Type>> {
    const allMessages = (await this.pluto.getAllMessages());
    const message = allMessages.find((message) => {
      return message.thid === thid && message.piuri === ProtocolType.DidcommRequestPresentation;
    });
    if (message) {
      const attachment = message.attachments.at(0);
      if (!attachment) {
        throw new AgentError.UnsupportedAttachmentType("Invalid presentation message, attachment missing");
      }
      const presentationDefinitionRequest = Message.Attachment.extractJSON(attachment);
      return presentationDefinitionRequest;
    }
    throw new AgentError.UnsupportedAttachmentType("Cannot find any message with that threadID");
  }

  async handlePresentation<Type extends CredentialType = CredentialType.JWT>(presentation: Presentation): Promise<boolean> {
    const attachment = presentation.attachments.at(0);
    if (!attachment) {
      throw new AgentError.UnsupportedAttachmentType("Invalid presentation message, attachment missing");
    }
    if (!presentation.thid) {
      throw new AgentError.UnsupportedAttachmentType("Cannot find any message with that threadID");
    }
    const presentationSubmission = Message.Attachment.extractJSON(attachment);
    const presentationDefinitionRequest = await this.getPresentationDefinitionByThid<Type>(presentation.thid!);
    const options = {
      presentationDefinitionRequest
    };
    const verified = await this.pollux.verifyPresentationSubmission(
      presentationSubmission,
      options
    );
    return verified;
  }

  /**
   * Asyncronously create a verifiablePresentation from a valid stored verifiableCredential
   * This is used when the verified requests a specific verifiable credential, this will create the actual
   * instance of the presentation which we can share with the verifier.
   *
   * @async
   * @param {RequestPresentation} message
   * @param {VerifiableCredential} credential
   * @returns {Promise<Presentation>}
   */
  async createPresentationForRequestProof(
    message: RequestPresentation,
    credential: Credential
  ): Promise<Presentation> {
    const attachment = message.attachments.at(0);
    if (!attachment) {
      throw new AgentError.OfferDoesntProvideEnoughInformation();
    }
    const attachmentFormat = attachment.format ?? 'unknown';
    const presentationRequest = this.parseProofRequest(attachment);
    const proof = attachmentFormat === AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS ?
      await this.handlePresentationDefinitionRequest(presentationRequest, credential) :
      await this.handlePresentationRequest(presentationRequest, credential);

    const presentationAttachment = AttachmentDescriptor.build(
      proof,
      uuid(),
      'application/json',
      undefined,
      AttachmentFormats.ANONCREDS_PROOF
    );
    const presentation = new Presentation(
      {
        comment: message.body.comment,
        goalCode: message.body.goalCode
      },
      [
        presentationAttachment,
      ],
      message.to,
      message.from,
      message.thid ?? message.id
    );
    return presentation;
  }


  /**
   * This method can be used by holders in order to disclose the value of a Credential
   * JWT are just encoded plainText
   * Anoncreds will really need to be disclosed as the fields are encoded.
   *
   * @param {Credential} credential
   * @returns {AttributeType}
   */
  async revealCredentialFields(credential: Credential, fields: string[], linkSecret: string) {
    return this.pollux.revealCredentialFields(credential, fields, linkSecret);
  }


  /**
   * match the Proof request to return relevant PresentationRequest.
   * Proof Request comes from a Message Attachment.
   * 
   * @param {AttachmentDescriptor} data - presentation proof request
   * @returns {PresentationRequest}
   * @throws
   */
  private parseProofRequest(attachment: AttachmentDescriptor): PresentationRequest {
    const data = Message.Attachment.extractJSON(attachment);
    if (attachment.format === AttachmentFormats.ANONCREDS_PROOF_REQUEST) {
      return new PresentationRequest(AttachmentFormats.AnonCreds, data);
    }
    if (attachment.format === CredentialType.JWT) {
      return new PresentationRequest(AttachmentFormats.JWT, data);
    }
    if (attachment.format === AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS) {
      return new PresentationRequest(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS, data);
    }
    throw new Error("Unsupported Proof Request");
  }

  private async handlePresentationDefinitionRequest(
    request: PresentationRequest,
    credential: Credential,
  ): Promise<string> {
    if (request.isType<CredentialType.JWT>(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {
      if (credential instanceof JWTCredential) {
        const privateKeys = await this.pluto.getDIDPrivateKeysByDID(DID.fromString(credential.subject));
        const privateKey = privateKeys.at(0);
        if (!privateKey) {
          throw new Error("Undefined privatekey from credential subject.");
        }
        if (!request.isType(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {
          throw new Error("Undefined privatekey from credential subject.");
        }
        const presentationSubmission = await this.pollux.createPresentationSubmission(
          request.toJSON(),
          credential,
          privateKey
        );
        return JSON.stringify(presentationSubmission);
      }
    }
    if (request.isType<CredentialType.AnonCreds>(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {
      if (credential instanceof AnonCredsCredential) {
        const storedLinkSecret = await this.pluto.getLinkSecret();
        if (!storedLinkSecret) {
          throw new Error("Link secret not found.");
        }
        const presentationSubmission = await this.pollux.createPresentationSubmission(
          request.toJSON(),
          credential,
          storedLinkSecret
        );
        return JSON.stringify(presentationSubmission);
      }
    }

    throw new Error("Not implemented");
  }

  private async handlePresentationRequest(
    request: PresentationRequest,
    credential: Credential
  ): Promise<string> {
    if (credential instanceof AnonCredsCredential && request.isType(AttachmentFormats.AnonCreds)) {
      const linkSecret = await this.pluto.getLinkSecret();
      if (!linkSecret) {
        throw new AgentError.CannotFindLinkSecret();
      }
      const presentation = await this.pollux.createPresentationProof(request, credential, { linkSecret });
      return JSON.stringify(presentation);
    }
    if (credential instanceof JWTCredential && request.isType(AttachmentFormats.JWT)) {
      if (!credential.isProvable()) {
        throw new Error("Credential is not Provable");
      }
      const subjectDID = DID.from(credential.subject);
      const prismPrivateKeys = await this.pluto.getDIDPrivateKeysByDID(subjectDID);
      const prismPrivateKey = prismPrivateKeys.at(0);
      if (prismPrivateKey === undefined) {
        throw new AgentError.CannotFindDIDPrivateKey();
      }
      const signedJWT = await this.pollux.createPresentationProof(request, credential, {
        did: subjectDID,
        privateKey: prismPrivateKey
      });
      return signedJWT;
    }
    throw new AgentError.UnhandledPresentationRequest();
  }
}

1	import { base64 } from "multiformats/bases/base64";
2
3	import {
4	AgentError,
5	Apollo,
6	AttachmentBase64,
7	AttachmentDescriptor,
8	Castor,
9	Credential,
10	CredentialType,
11	CredentialIssueOptions,
12	Curve,
13	DID,
14	KeyProperties,
15	KeyTypes,
16	Seed,
17	Message,
18	Pluto,
19	Pollux,
20	CredentialMetadata,
21	PresentationOptions,
22	Mercury,
23	PresentationDefinitionRequest,
24	PresentationClaims,
25	AttachmentFormats,
26	PolluxError,
27	} from "../domain";
28
29	import { AnonCredsCredential } from "../pollux/models/AnonCredsVerifiableCredential";
30	import { JWTCredential } from "../pollux/models/JWTVerifiableCredential";
31	import { PresentationRequest } from "../pollux/models/PresentationRequest";
32
33	import { OfferCredential } from "./protocols/issueCredential/OfferCredential";
34	import { createRequestCredentialBody, RequestCredential } from "./protocols/issueCredential/RequestCredential";
35	import { IssueCredential } from "./protocols/issueCredential/IssueCredential";
36	import { Presentation } from "./protocols/proofPresentation/Presentation";
37	import { RequestPresentation } from "./protocols/proofPresentation/RequestPresentation";
38
39	import { AgentCredentials as AgentCredentialsClass, AgentDIDHigherFunctions } from "./types";
40	import { PrismKeyPathIndexTask } from "./Agent.PrismKeyPathIndexTask";
41	import { uuid } from "@stablelib/uuid";
42	import { ProtocolType } from "./protocols/ProtocolTypes";
43	import { validatePresentationClaims } from "../pollux/utils/claims";
44
45	export class AgentCredentials implements AgentCredentialsClass {
46	/**
47	* Creates an instance of AgentCredentials.
48	*
49	* @constructor
50	* @param {Apollo} apollo
51	* @param {Castor} castor
52	* @param {Pluto} pluto
53	* @param {Pollux} pollux
54	* @param {Seed} seed
55	*/
56	constructor(
57	protected apollo: Apollo,
58	protected castor: Castor,
59	protected pluto: Pluto,
60	protected pollux: Pollux,
61	protected seed: Seed,
62	protected mercury: Mercury,
63	protected agentDIDHigherFunctions: AgentDIDHigherFunctions
64	) {}
65
66
67	private createPresentationDefinitionRequest<Type extends CredentialType = CredentialType.JWT>(
68	type: Type,
69	definition: PresentationDefinitionRequest<Type>,
70	from: DID,
71	to: DID
72	) {
73	const attachmentFormat = type === CredentialType.JWT ?	×
74	AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS :
75	AttachmentFormats.ANONCREDS_PROOF_REQUEST;
76
77	return new RequestPresentation(	×
78	{
79	proofTypes: [],
80	},
81	[
82	AttachmentDescriptor.build(
83	definition,
84	uuid(),
85	'application/json',
86	undefined,
87	attachmentFormat
88	)
89	],
90	from,
91	to,
92	uuid()
93	);
94	}
95
96	async initiatePresentationRequest(
97	type: CredentialType,
98	toDID: DID,
99	claims: PresentationClaims<CredentialType>
100	): Promise<RequestPresentation> {
101	const didDocument = await this.castor.resolveDID(toDID.toString());	×
102	const newPeerDID = await this.agentDIDHigherFunctions.createNewPeerDID(	×
103	didDocument.services,
104	true
105	);
106
107	if (type === CredentialType.AnonCreds) {	×
108	if (!validatePresentationClaims(claims, CredentialType.AnonCreds)) {	×
NEW 109	throw new PolluxError.InvalidPresentationDefinitionError("Anoncreds Claims are invalid");	×
110	}
111
UNCOV 112	const presentationDefinitionRequest = await this.pollux.createPresentationDefinitionRequest(	×
113	type,
114	claims,
115	new PresentationOptions({}, CredentialType.AnonCreds)
116	);
117
UNCOV 118	return this.createPresentationDefinitionRequest<CredentialType.AnonCreds>(	×
119	type,
120	presentationDefinitionRequest,
121	newPeerDID,
122	toDID
123	);
124	}
125
126	if (type === CredentialType.JWT) {	×
127	if (!validatePresentationClaims(claims, CredentialType.JWT)) {	×
NEW 128	throw new PolluxError.InvalidPresentationDefinitionError("JWT Claims are invalid");	×
129	}
130	const presentationDefinitionRequest = await this.pollux.createPresentationDefinitionRequest<CredentialType.JWT>(	×
131	type,
132	claims,
133	new PresentationOptions({
134	jwt: {
135	jwtAlg: ['ES256K']
136	},
137	challenge: "Sign this text " + uuid(),
138	domain: 'N/A'
139	})
140	);
141	return this.createPresentationDefinitionRequest<CredentialType.JWT>(	×
142	type,
143	presentationDefinitionRequest,
144	newPeerDID,
145	toDID
146	);
147	}
148
NEW 149	throw new PolluxError.CredentialTypeNotSupported();	×
150	}
151
152	async verifiableCredentials(): Promise<Credential[]> {
153	return await this.pluto.getAllCredentials();	×
154	}
155
156	/**
157	* Extract the verifiableCredential object from the Issue credential message asyncronously
158	*
159	* @async
160	* @param {IssueCredential} message
161	* @returns {Promise<VerifiableCredential>}
162	*/
163	async processIssuedCredentialMessage(
164	issueCredential: IssueCredential
165	): Promise<Credential> {
166	const credentialType = this.pollux.extractCredentialFormatFromMessage(	11✔
167	issueCredential.makeMessage()
168	);
169	const attachment = issueCredential.attachments.at(0)?.data;	10✔
170
171	if (!attachment) {	10!
172	throw new Error("No attachment");	×
173	}
174
175	const credData = base64.baseDecode((attachment as AttachmentBase64).base64);	10✔
176
177	const parseOpts: CredentialIssueOptions = {	10✔
178	type: credentialType,
179	};
180
181	if (credentialType === CredentialType.AnonCreds) {	10✔
182	const linkSecret = await this.pluto.getLinkSecret();	6✔
183
184	parseOpts.linkSecret = linkSecret?.secret;	6✔
185
186	const credentialMetadata = await this.pluto.getCredentialMetadata(	6✔
187	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
188	issueCredential.thid!
189	);
190
191	if (!credentialMetadata \|\| !credentialMetadata.isType(CredentialType.AnonCreds)) {	6✔
192	throw new Error("Invalid credential Metadata");	1✔
193	}
194
195	parseOpts.credentialMetadata = credentialMetadata.toJSON();	5✔
196	}
197
198	const credential = await this.pollux.parseCredential(credData, parseOpts);	9✔
199
200	await this.pluto.storeCredential(credential);	9✔
201
202	return credential;	9✔
203	}
204
205	/**
206	* Asyncronously prepare a request credential message from a valid offerCredential for now supporting w3c verifiable credentials offers.
207	*
208	* @async
209	* @param {OfferCredential} offer
210	* @returns {Promise<RequestCredential>}
211	*/
212	async prepareRequestCredentialWithIssuer(
213	offer: OfferCredential
214	): Promise<RequestCredential> {
215	const message = offer.makeMessage();	5✔
216	const credentialType =
217	this.pollux.extractCredentialFormatFromMessage(message);	5✔
218
219	let credRequestBuffer: string;
220
221	if (credentialType === CredentialType.AnonCreds) {	3✔
222	const linkSecret = await this.pluto.getLinkSecret();	1✔
223	if (!linkSecret) {	1!
224	throw new Error("No linkSecret available.");	×
225	}
226
227	const [credentialRequest, credentialRequestMetadata] =
228	await this.pollux.processAnonCredsCredential(message, { linkSecret });	1✔
229
230	credRequestBuffer = JSON.stringify(credentialRequest);	1✔
231
232	// TODO can we fallback here? would need another identifier
233	const metaname = offer.thid;	1✔
234
235	if (!metaname) {	1!
236	throw new Error("Missing offer.thid");	×
237	}
238
239	const metadata = new CredentialMetadata(CredentialType.AnonCreds, metaname, credentialRequestMetadata);	1✔
240
241	await this.pluto.storeCredentialMetadata(metadata);	1✔
242	} else if (credentialType === CredentialType.JWT) {	2✔
243	// ?? duplicated Agent.DIDHigherFunctions.createNewPrismDID
244	const getIndexTask = new PrismKeyPathIndexTask(this.pluto);	1✔
245	const keyIndex = await getIndexTask.run();	1✔
246	const privateKey = await this.apollo.createPrivateKey({	1✔
247	[KeyProperties.curve]: Curve.SECP256K1,
248	[KeyProperties.index]: keyIndex,
249	[KeyProperties.type]: KeyTypes.EC,
250	[KeyProperties.seed]: this.seed.value,
251	});
252
253	const did = await this.castor.createPrismDID(privateKey.publicKey());	1✔
254
255	await this.pluto.storeDID(did, privateKey);	1✔
256
257	credRequestBuffer = await this.pollux.processJWTCredential(message, {	1✔
258	did: did,
259	keyPair: {
260	curve: Curve.SECP256K1,
261	privateKey: privateKey,
262	publicKey: privateKey.publicKey(),
263	},
264	});
265	} else {
266	throw new AgentError.InvalidCredentialFormats();	1✔
267	}
268
269	const requestCredentialBody = createRequestCredentialBody(	2✔
270	offer.body.formats,
271	offer.body.goalCode,
272	offer.body.comment
273	);
274
275	// TODO: remove assertions
276	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
277	const from = offer.to!;	2✔
278	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
279	const to = offer.from!;	2✔
280	const thid = offer.thid;	2✔
281
282	const credentialFormat =
283	credentialType === CredentialType.AnonCreds	2✔
284	? AttachmentFormats.ANONCREDS_REQUEST
285	: credentialType === CredentialType.JWT	1!
286	? CredentialType.JWT
287	: CredentialType.Unknown;
288
289	const attachments = [	2✔
290	new AttachmentDescriptor(
291	{
292	base64: base64.baseEncode(Buffer.from(credRequestBuffer)),
293	},
294	credentialFormat,
295	undefined,
296	undefined,
297	// TODO: confirm what is the format that backend expects us to send AnonCreds VS JWT
298	credentialFormat
299	),
300	];
301
302	const requestCredential = new RequestCredential(	2✔
303	requestCredentialBody,
304	attachments,
305	from,
306	to,
307	thid
308	);
309
310	attachments.forEach((attachment) => {	2✔
311	requestCredential.body.formats.push({	2✔
312	attach_id: attachment.id,
313	format: credentialFormat,
314	});
315	});
316
317	return requestCredential;	2✔
318	}
319
320	private async getPresentationDefinitionByThid<Type extends CredentialType = CredentialType.JWT>(thid: string): Promise<PresentationDefinitionRequest<Type>> {
NEW 321	const allMessages = (await this.pluto.getAllMessages());	×
322	const message = allMessages.find((message) => {	×
NEW 323	return message.thid === thid && message.piuri === ProtocolType.DidcommRequestPresentation;	×
324	});
325	if (message) {	×
326	const attachment = message.attachments.at(0);	×
327	if (!attachment) {	×
NEW 328	throw new AgentError.UnsupportedAttachmentType("Invalid presentation message, attachment missing");	×
329	}
330	const presentationDefinitionRequest = Message.Attachment.extractJSON(attachment);	×
NEW 331	return presentationDefinitionRequest;	×
332	}
NEW 333	throw new AgentError.UnsupportedAttachmentType("Cannot find any message with that threadID");	×
334	}
335
336	async handlePresentation<Type extends CredentialType = CredentialType.JWT>(presentation: Presentation): Promise<boolean> {
337	const attachment = presentation.attachments.at(0);	×
338	if (!attachment) {	×
NEW 339	throw new AgentError.UnsupportedAttachmentType("Invalid presentation message, attachment missing");	×
340	}
341	if (!presentation.thid) {	×
NEW 342	throw new AgentError.UnsupportedAttachmentType("Cannot find any message with that threadID");	×
343	}
344	const presentationSubmission = Message.Attachment.extractJSON(attachment);	×
NEW 345	const presentationDefinitionRequest = await this.getPresentationDefinitionByThid<Type>(presentation.thid!);	×
346	const options = {	×
347	presentationDefinitionRequest
348	};
349	const verified = await this.pollux.verifyPresentationSubmission(	×
350	presentationSubmission,
351	options
352	);
NEW 353	return verified;	×
354	}
355
356	/**
357	* Asyncronously create a verifiablePresentation from a valid stored verifiableCredential
358	* This is used when the verified requests a specific verifiable credential, this will create the actual
359	* instance of the presentation which we can share with the verifier.
360	*
361	* @async
362	* @param {RequestPresentation} message
363	* @param {VerifiableCredential} credential
364	* @returns {Promise<Presentation>}
365	*/
366	async createPresentationForRequestProof(
367	message: RequestPresentation,
368	credential: Credential
369	): Promise<Presentation> {
370	const attachment = message.attachments.at(0);	7✔
371	if (!attachment) {	7✔
372	throw new AgentError.OfferDoesntProvideEnoughInformation();	1✔
373	}
374	const attachmentFormat = attachment.format ?? 'unknown';	6!
375	const presentationRequest = this.parseProofRequest(attachment);	6✔
376	const proof = attachmentFormat === AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS ?	5!
377	await this.handlePresentationDefinitionRequest(presentationRequest, credential) :
378	await this.handlePresentationRequest(presentationRequest, credential);
379
380	const presentationAttachment = AttachmentDescriptor.build(	2✔
381	proof,
382	uuid(),
383	'application/json',
384	undefined,
385	AttachmentFormats.ANONCREDS_PROOF
386	);
387	const presentation = new Presentation(	2✔
388	{
389	comment: message.body.comment,
390	goalCode: message.body.goalCode
391	},
392	[
393	presentationAttachment,
394	],
395	message.to,
396	message.from,
397	message.thid ?? message.id	4✔
398	);
399	return presentation;	2✔
400	}
401
402
403	/**
404	* This method can be used by holders in order to disclose the value of a Credential
405	* JWT are just encoded plainText
406	* Anoncreds will really need to be disclosed as the fields are encoded.
407	*
408	* @param {Credential} credential
409	* @returns {AttributeType}
410	*/
411	async revealCredentialFields(credential: Credential, fields: string[], linkSecret: string) {
NEW 412	return this.pollux.revealCredentialFields(credential, fields, linkSecret);	×
413	}
414
415
416	/**
417	* match the Proof request to return relevant PresentationRequest.
418	* Proof Request comes from a Message Attachment.
419	*
420	* @param {AttachmentDescriptor} data - presentation proof request
421	* @returns {PresentationRequest}
422	* @throws
423	*/
424	private parseProofRequest(attachment: AttachmentDescriptor): PresentationRequest {
425	const data = Message.Attachment.extractJSON(attachment);	6✔
426	if (attachment.format === AttachmentFormats.ANONCREDS_PROOF_REQUEST) {	6✔
427	return new PresentationRequest(AttachmentFormats.AnonCreds, data);	1✔
428	}
429	if (attachment.format === CredentialType.JWT) {	5✔
430	return new PresentationRequest(AttachmentFormats.JWT, data);	4✔
431	}
432	if (attachment.format === AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS) {	1!
NEW 433	return new PresentationRequest(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS, data);	×
434	}
435	throw new Error("Unsupported Proof Request");	1✔
436	}
437
438	private async handlePresentationDefinitionRequest(
439	request: PresentationRequest,
440	credential: Credential,
441	): Promise<string> {
442	if (request.isType<CredentialType.JWT>(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {	×
443	if (credential instanceof JWTCredential) {	×
444	const privateKeys = await this.pluto.getDIDPrivateKeysByDID(DID.fromString(credential.subject));	×
445	const privateKey = privateKeys.at(0);	×
446	if (!privateKey) {	×
447	throw new Error("Undefined privatekey from credential subject.");	×
448	}
449	if (!request.isType(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {	×
450	throw new Error("Undefined privatekey from credential subject.");	×
451	}
452	const presentationSubmission = await this.pollux.createPresentationSubmission(	×
453	request.toJSON(),
454	credential,
455	privateKey
456	);
NEW 457	return JSON.stringify(presentationSubmission);	×
458	}
459	}
460	if (request.isType<CredentialType.AnonCreds>(AttachmentFormats.PRESENTATION_EXCHANGE_DEFINITIONS)) {	×
461	if (credential instanceof AnonCredsCredential) {	×
462	const storedLinkSecret = await this.pluto.getLinkSecret();	×
463	if (!storedLinkSecret) {	×
464	throw new Error("Link secret not found.");	×
465	}
466	const presentationSubmission = await this.pollux.createPresentationSubmission(	×
467	request.toJSON(),
468	credential,
469	storedLinkSecret
470	);
NEW 471	return JSON.stringify(presentationSubmission);	×
472	}
473	}
474
NEW 475	throw new Error("Not implemented");	×
476	}
477
478	private async handlePresentationRequest(
479	request: PresentationRequest,
480	credential: Credential
481	): Promise<string> {
482	if (credential instanceof AnonCredsCredential && request.isType(AttachmentFormats.AnonCreds)) {	5✔
483	const linkSecret = await this.pluto.getLinkSecret();	1✔
484	if (!linkSecret) {	1!
485	throw new AgentError.CannotFindLinkSecret();	×
486	}
487	const presentation = await this.pollux.createPresentationProof(request, credential, { linkSecret });	1✔
488	return JSON.stringify(presentation);	1✔
489	}
490	if (credential instanceof JWTCredential && request.isType(AttachmentFormats.JWT)) {	4!
491	if (!credential.isProvable()) {	4!
492	throw new Error("Credential is not Provable");	×
493	}
494	const subjectDID = DID.from(credential.subject);	4✔
495	const prismPrivateKeys = await this.pluto.getDIDPrivateKeysByDID(subjectDID);	3✔
496	const prismPrivateKey = prismPrivateKeys.at(0);	3✔
497	if (prismPrivateKey === undefined) {	3✔
498	throw new AgentError.CannotFindDIDPrivateKey();	2✔
499	}
500	const signedJWT = await this.pollux.createPresentationProof(request, credential, {	1✔
501	did: subjectDID,
502	privateKey: prismPrivateKey
503	});
504	return signedJWT;	1✔
505	}
506	throw new AgentError.UnhandledPresentationRequest();	×
507	}
508	}

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

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