9163093139

Committed 20 May 2024 06:12PM UTC coverage: 68.686% (-0.03%) from 68.711%

Build # 9163093139

Build Type

Pull #219

github

Committed by

web-flow

Commit Message

Merge cdd8ffb72 into ae4e5e456

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

Run Details

999 of 1620 branches covered (61.67%)

Branch coverage included in aggregate %.

124 of 169 new or added lines in 6 files covered. (73.37%)

100 existing lines in 8 files now uncovered.

2085 of 2870 relevant lines covered (72.65%)

15.76 hits per line

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

68.89

/src/mercury/Mercury.ts

import * as Domain from "../domain";
import { MercuryError } from "../domain/models/Errors";
import { Mercury as MercuryInterface } from "../domain/buildingBlocks/Mercury";
import { DIDCommProtocol } from "./DIDCommProtocol";
import { Api, DID } from "../domain";
import { MediaType } from "./helpers/MediaType";
import { Castor } from "../domain/buildingBlocks/Castor";
import { ForwardMessage } from "./forward/ForwardMessage";

/**
 * Mercury is a powerful and flexible library for working with decentralized identifiers and secure communications
 * protocols. Whether you are a developer looking to build a secure and private messaging app or a more complex
 * decentralized system requiring trusted peer-to-peer connections, Mercury provides the tools and features you need to
 * establish, manage, and secure your communications easily.
 *
 * @export
 * @class Mercury
 * @typedef {Mercury}
 */
export default class Mercury implements MercuryInterface {
  /**
   * Creates an instance of Mercury.
   *
   * @constructor
   * @param {Castor} castor
   * @param {DIDCommProtocol} protocol
   * @param {Api} api
   */
  constructor(
    public castor: Castor,
    public protocol: DIDCommProtocol,
    public api: Api
  ) { }

  /**
   * Asynchronously packs a given message object into a string representation. This function may throw an error if the
   * message object is invalid.
   *
   * @param {Domain.Message} message
   * @returns {Promise<string>}
   */
  packMessage(message: Domain.Message): Promise<string> {
    const toDid = message.to;
    const fromDid = message.from;

    if (this.notDid(toDid)) throw new MercuryError.NoRecipientDIDSetError();

    return this.protocol.packEncrypted(message, toDid, fromDid);
  }

  /**
   * Asynchronously unpacks a given string representation of a message into a message object. This
   * function may throw an error if the string is not a valid message representation.
   *
   * @param {string} message
   * @returns {Promise<Domain.Message>}
   */
  unpackMessage(message: string): Promise<Domain.Message> {
    return this.protocol.unpack(message);
  }

  /**
   * Asynchronously sends a given message and returns the response data.
   *
   * @async
   * @template T
   * @param {Domain.Message} message
   * @returns {Promise<T>}
   */
  async sendMessage<T>(message: Domain.Message): Promise<T> {
    const toDid = message.to;

    if (this.notDid(toDid)) throw new MercuryError.NoRecipientDIDSetError();

    const document = await this.castor.resolveDID(toDid.toString());
    const packedMessage = await this.packMessage(message);
    if (this.requiresForwarding(document)) {
      const mediatorDid = this.getDIDCommDID(document);
      if (!mediatorDid) {
        throw new MercuryError.NoValidServiceFoundError();
      }
      const forwardMessage = this.prepareForwardMessage(
        message,
        packedMessage,
        mediatorDid
      );
      const packedForwardMsg = await this.packMessage(
        forwardMessage.makeMessage()
      );
      const mediatorDocument = await this.castor.resolveDID(
        mediatorDid.toString()
      );
      const url = this.getDIDCommURL(mediatorDocument);
      return this.makeRequest<T>(url, packedForwardMsg);
    }

    const service = document.services.find((x) => x.isDIDCommMessaging);
    return this.makeRequest<T>(service, packedMessage);
  }

  private async makeRequest<T>(
    service: Domain.Service | URL | undefined,
    message: string
  ) {
    if (service == undefined) throw new MercuryError.NoValidServiceFoundError();

    const headers = new Map();
    headers.set("Content-type", MediaType.ContentTypeEncrypted);

    const requestUrl =
      service instanceof URL ? service.toString() : service.serviceEndpoint.uri;

    const response = await this.api.request<T>(
      "POST",
      requestUrl,
      new Map(),
      headers,
      message
    );
    return response.body;
  }

  /**
   * Asynchronously sends a given message and returns the response message object.
   *
   * @async
   * @param {Domain.Message} message
   * @returns {Promise<Domain.Message>}
   */
  async sendMessageParseMessage(
    message: Domain.Message
  ): Promise<Domain.Message> {
    const responseBody = await this.sendMessage<any>(message);
    const responseJSON = JSON.stringify(responseBody);
    return this.unpackMessage(responseJSON);
  }

  private notDid(did: Domain.DID | undefined): did is undefined {
    if (!did) {
      return true;
    }
    if (!did?.method || !did.methodId || !did.schema || !did.toString) {
      return true;
    }
    if (typeof did.method !== "string" || typeof did.methodId !== "string" || typeof did.schema !== "string") {
      return true;
    }
    if (typeof did.toString !== "function") {
      return true;
    }
    return false
  }

  private prepareForwardMessage(
    msg: Domain.Message,
    encrypted: string,
    mediatorDID: DID
  ): ForwardMessage {
    if (!msg.from) {
      throw new MercuryError.NoSenderDIDSetError();
    }
    if (!msg.to) {
      throw new MercuryError.NoDIDReceiverSetError();
    }
    return new ForwardMessage(
      { next: msg.to.toString() },
      msg.from,
      mediatorDID,
      encrypted
    );
  }

  private getDIDCommURL(document: Domain.DIDDocument): URL | undefined {
    const uri = document.services.find((x) => x.isDIDCommMessaging)
      ?.serviceEndpoint?.uri;
    if (uri) {
      return new URL(uri);
    }
    return undefined;
  }

  private getDIDCommDID(document: Domain.DIDDocument): DID | undefined {
    const uri = document.services.find((x) => x.isDIDCommMessaging)
      ?.serviceEndpoint?.uri;
    try {
      //It Is okey to fail
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      const did = this.castor.parseDID(uri!);
      return did;
    } catch {
      return undefined;
    }
  }

  private requiresForwarding(document: Domain.DIDDocument): boolean {
    if (this.getDIDCommDID(document) !== undefined) {
      return true;
    }
    return false;
  }
}

1	import * as Domain from "../domain";
2	import { MercuryError } from "../domain/models/Errors";
3	import { Mercury as MercuryInterface } from "../domain/buildingBlocks/Mercury";
4	import { DIDCommProtocol } from "./DIDCommProtocol";
5	import { Api, DID } from "../domain";
6	import { MediaType } from "./helpers/MediaType";
7	import { Castor } from "../domain/buildingBlocks/Castor";
8	import { ForwardMessage } from "./forward/ForwardMessage";
9
10	/**
11	* Mercury is a powerful and flexible library for working with decentralized identifiers and secure communications
12	* protocols. Whether you are a developer looking to build a secure and private messaging app or a more complex
13	* decentralized system requiring trusted peer-to-peer connections, Mercury provides the tools and features you need to
14	* establish, manage, and secure your communications easily.
15	*
16	* @export
17	* @class Mercury
18	* @typedef {Mercury}
19	*/
20	export default class Mercury implements MercuryInterface {
21	/**
22	* Creates an instance of Mercury.
23	*
24	* @constructor
25	* @param {Castor} castor
26	* @param {DIDCommProtocol} protocol
27	* @param {Api} api
28	*/
29	constructor(
30	public castor: Castor,
31	public protocol: DIDCommProtocol,
32	public api: Api
33	) { }
34
35	/**
36	* Asynchronously packs a given message object into a string representation. This function may throw an error if the
37	* message object is invalid.
38	*
39	* @param {Domain.Message} message
40	* @returns {Promise<string>}
41	*/
42	packMessage(message: Domain.Message): Promise<string> {
43	const toDid = message.to;	5✔
44	const fromDid = message.from;	5✔
45
46	if (this.notDid(toDid)) throw new MercuryError.NoRecipientDIDSetError();	5✔
47
48	return this.protocol.packEncrypted(message, toDid, fromDid);	3✔
49	}
50
51	/**
52	* Asynchronously unpacks a given string representation of a message into a message object. This
53	* function may throw an error if the string is not a valid message representation.
54	*
55	* @param {string} message
56	* @returns {Promise<Domain.Message>}
57	*/
58	unpackMessage(message: string): Promise<Domain.Message> {
59	return this.protocol.unpack(message);	1✔
60	}
61
62	/**
63	* Asynchronously sends a given message and returns the response data.
64	*
65	* @async
66	* @template T
67	* @param {Domain.Message} message
68	* @returns {Promise<T>}
69	*/
70	async sendMessage<T>(message: Domain.Message): Promise<T> {
71	const toDid = message.to;	2✔
72
73	if (this.notDid(toDid)) throw new MercuryError.NoRecipientDIDSetError();	2✔
74
75	const document = await this.castor.resolveDID(toDid.toString());	1✔
76	const packedMessage = await this.packMessage(message);	1✔
77	if (this.requiresForwarding(document)) {	1!
78	const mediatorDid = this.getDIDCommDID(document);	1✔
79	if (!mediatorDid) {	1!
80	throw new MercuryError.NoValidServiceFoundError();	×
81	}
82	const forwardMessage = this.prepareForwardMessage(	1✔
83	message,
84	packedMessage,
85	mediatorDid
86	);
87	const packedForwardMsg = await this.packMessage(	1✔
88	forwardMessage.makeMessage()
89	);
90	const mediatorDocument = await this.castor.resolveDID(	1✔
91	mediatorDid.toString()
92	);
93	const url = this.getDIDCommURL(mediatorDocument);	1✔
94	return this.makeRequest<T>(url, packedForwardMsg);	1✔
95	}
96
97	const service = document.services.find((x) => x.isDIDCommMessaging);	×
98	return this.makeRequest<T>(service, packedMessage);	×
99	}
100
101	private async makeRequest<T>(
102	service: Domain.Service \| URL \| undefined,
103	message: string
104	) {
105	if (service == undefined) throw new MercuryError.NoValidServiceFoundError();	1!
106
107	const headers = new Map();	×
108	headers.set("Content-type", MediaType.ContentTypeEncrypted);	×
109
110	const requestUrl =
111	service instanceof URL ? service.toString() : service.serviceEndpoint.uri;	×
112
113	const response = await this.api.request<T>(	×
114	"POST",
115	requestUrl,
116	new Map(),
117	headers,
118	message
119	);
120	return response.body;	×
121	}
122
123	/**
124	* Asynchronously sends a given message and returns the response message object.
125	*
126	* @async
127	* @param {Domain.Message} message
128	* @returns {Promise<Domain.Message>}
129	*/
130	async sendMessageParseMessage(
131	message: Domain.Message
132	): Promise<Domain.Message> {
133	const responseBody = await this.sendMessage<any>(message);	1✔
134	const responseJSON = JSON.stringify(responseBody);	1✔
135	return this.unpackMessage(responseJSON);	1✔
136	}
137
138	private notDid(did: Domain.DID \| undefined): did is undefined {
139	if (!did) {	7✔
140	return true;	3✔
141	}
142	if (!did?.method \|\| !did.methodId \|\| !did.schema \|\| !did.toString) {	4!
UNCOV 143	return true;	×
144	}
145	if (typeof did.method !== "string" \|\| typeof did.methodId !== "string" \|\| typeof did.schema !== "string") {	4!
UNCOV 146	return true;	×
147	}
148	if (typeof did.toString !== "function") {	4!
UNCOV 149	return true;	×
150	}
151	return false	4✔
152	}
153
154	private prepareForwardMessage(
155	msg: Domain.Message,
156	encrypted: string,
157	mediatorDID: DID
158	): ForwardMessage {
159	if (!msg.from) {	1!
UNCOV 160	throw new MercuryError.NoSenderDIDSetError();	×
161	}
162	if (!msg.to) {	1!
UNCOV 163	throw new MercuryError.NoDIDReceiverSetError();	×
164	}
165	return new ForwardMessage(	1✔
166	{ next: msg.to.toString() },
167	msg.from,
168	mediatorDID,
169	encrypted
170	);
171	}
172
173	private getDIDCommURL(document: Domain.DIDDocument): URL \| undefined {
174	const uri = document.services.find((x) => x.isDIDCommMessaging)	1✔
175	?.serviceEndpoint?.uri;
176	if (uri) {	1!
UNCOV 177	return new URL(uri);	×
178	}
179	return undefined;	1✔
180	}
181
182	private getDIDCommDID(document: Domain.DIDDocument): DID \| undefined {
183	const uri = document.services.find((x) => x.isDIDCommMessaging)	2✔
184	?.serviceEndpoint?.uri;
185	try {	2✔
186	//It Is okey to fail
187	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
188	const did = this.castor.parseDID(uri!);	2✔
189	return did;	2✔
190	} catch {
UNCOV 191	return undefined;	×
192	}
193	}
194
195	private requiresForwarding(document: Domain.DIDDocument): boolean {
196	if (this.getDIDCommDID(document) !== undefined) {	1!
197	return true;	1✔
198	}
UNCOV 199	return false;	×
200	}
201	}

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

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