10664806424

Committed 02 Sep 2024 09:46AM UTC coverage: 72.462% (+0.2%) from 72.246%

Build # 10664806424

Build Type

Pull #280

github

Committed by

web-flow

Commit Message

Merge 3a384f835 into a6a72ff6f

Pull Request Pull Request #280: fix: improve parseInvitation to handle parsing oob properly

Run Details

1402 of 2127 branches covered (65.91%)

Branch coverage included in aggregate %.

28 of 33 new or added lines in 3 files covered. (84.85%)

22 existing lines in 1 file now uncovered.

2795 of 3665 relevant lines covered (76.26%)

23.53 hits per line

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

41.1

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

import { OutOfBandInvitation } from "./protocols/invitation/v2/OutOfBandInvitation";
import {
  AgentDIDHigherFunctions,
  AgentInvitations as AgentInvitationsClass,
  InvitationType,
  PrismOnboardingInvitation,
} from "./types";
import {
  Service as DIDDocumentService,
  ServiceEndpoint as DIDDocumentServiceEndpoint,
  Message,
} from "../domain";
import { AgentError } from "../domain/models/Errors";
import {
  findProtocolTypeByValue,
  ProtocolType,
} from "./protocols/ProtocolTypes";
import { Api } from "../domain/models/Api";
import { ConnectionsManager } from "./connectionsManager/ConnectionsManager";
import { DIDCommConnectionRunner } from "./protocols/connection/DIDCommConnectionRunner";
import { Pluto } from "../domain/buildingBlocks/Pluto";
import { DIDCommInvitationRunner } from "./protocols/invitation/v2/DIDCommInvitationRunner";
import { base64 } from "multiformats/bases/base64";

/**
 * An extension for the Edge agent that groups the functionality to parse, manage and
 *  respond to Cloud Agent onboarding and didcomm v2 invitations
 *
 * @export
 * @class AgentInvitations
 * @typedef {AgentInvitations}
 */
export class AgentInvitations implements AgentInvitationsClass {
  /**
   * Creates an instance of AgentInvitations.
   *
   * @constructor
   * @param {Pluto} pluto
   * @param {Api} api
   * @param {AgentDIDHigherFunctions} agentDIDHigherFunctions
   * @param {ConnectionsManager} connection
   */
  constructor(
    private pluto: Pluto,
    private api: Api,
    private agentDIDHigherFunctions: AgentDIDHigherFunctions,
    private connection: ConnectionsManager
  ) { }

  private decodeOOB(str: string) {
    const components = new URL(str);
    if (!components) {
      throw new AgentError.InvalidURLError();
    }
    const message = components.searchParams.get("_oob")
    if (!message) {
      throw new AgentError.InvalidURLError();
    }
    const dataJson = Buffer.from(base64.baseDecode(message)).toString();
    const json = JSON.parse(dataJson);
    return json
  }

  /**
   * Asyncronously parse an invitation from a valid json string
   *
   * @async
   * @param {string} str
   * @returns {Promise<InvitationType>}
   */
  async parseInvitation(str: string): Promise<InvitationType> {
    const url = this.decodeOOB(str);
    const messasgeType = url.piuri || url.type;
    const typeString = findProtocolTypeByValue(messasgeType);
    switch (typeString) {
      case ProtocolType.PrismOnboarding:
        return this.parsePrismInvitation(str);
      case ProtocolType.Didcomminvitation:
        return this.parseOOBInvitation(url);
    }

    throw new AgentError.UnknownInvitationTypeError();
  }

  async acceptInvitation(invitation: InvitationType, optionalAlias?: string): Promise<void> {
    if (invitation.type === ProtocolType.Didcomminvitation) {
      return this.acceptDIDCommInvitation(invitation, optionalAlias);
    }

    if (invitation instanceof PrismOnboardingInvitation) {
      return this.acceptPrismOnboardingInvitation(invitation);
    }

    throw new AgentError.InvitationIsInvalidError();
  }

  /**
   * Asyncronously accept a didcomm v2 invitation, will create a pair between the Agent
   *  its connecting with and the current owner's did
   *
   * @async
   * @param {OutOfBandInvitation} invitation
   * @returns {*}
   */
  async acceptDIDCommInvitation(invitation: OutOfBandInvitation, optionalAlias?: string) {
    if (!this.connection.mediationHandler.mediator) {
      throw new AgentError.NoMediatorAvailableError();
    }
    const [attachment] = invitation.attachments ?? [];
    if (!attachment) {
      const ownDID = await this.agentDIDHigherFunctions.createNewPeerDID(
        [],
        true
      );
      const pair = await new DIDCommConnectionRunner(
        invitation,
        this.pluto,
        ownDID,
        this.connection,
        optionalAlias
      ).run();
      await this.connection.addConnection(pair);
    } else {
      const ownDID = await this.agentDIDHigherFunctions.createNewPeerDID(
        [],
        true
      );
      const msg = Message.fromJson({
        ...attachment.payload,
        to: ownDID.toString()
      });
      await this.pluto.storeMessage(msg)
    }
  }

  /**
   * Asyncronously accept an onboarding invitation, used to onboard the current DID in the Cloud Agent.
   *
   * @async
   * @param {PrismOnboardingInvitation} invitation
   * @returns {Promise<void>}
   */
  async acceptPrismOnboardingInvitation(invitation: PrismOnboardingInvitation): Promise<void> {
    if (!invitation.from) {
      throw new AgentError.UnknownInvitationTypeError();
    }
    interface SendDID {
      did: string;
    }
    const body: SendDID = {
      did: invitation.from.toString(),
    };
    const response = await this.api.request(
      "POST",
      invitation.onboardEndpoint,
      new Map(),
      new Map(),
      body
    );
    if (response.httpStatus != 200) {
      throw new AgentError.FailedToOnboardError();
    }
  }

  /**
   * Asyncronously parse a prismOnboarding invitation from a string
   *
   * @async
   * @param {string} str
   * @returns {Promise<PrismOnboardingInvitation>}
   */
  async parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation> {
    try {
      const prismOnboarding =
        OutOfBandInvitation.parsePrismOnboardingInvitationFromJson(str);
      const url = prismOnboarding.onboardEndpoint;
      const services: DIDDocumentService[] = [
        new DIDDocumentService(
          "#didcomm-1",
          ["DIDCommMessaging"],
          new DIDDocumentServiceEndpoint(url, ["DIDCommMessaging"])
        ),
      ];
      const updateMediator = true;
      const did = await this.agentDIDHigherFunctions.createNewPeerDID(
        services,
        updateMediator
      );
      prismOnboarding.from = did;
      return prismOnboarding;
    } catch (e) {
      if (e instanceof Error) {
        throw new AgentError.UnknownInvitationTypeError(e.message);
      } else {
        throw e;
      }
    }
  }

  /**
   * Asyncronously parse an out of band invitation from a URI as the oob come in format of valid URL
   *
   * @async
   * @param {URL} str
   * @returns {Promise<OutOfBandInvitation>}
   */
  async parseOOBInvitation(str: URL | object): Promise<OutOfBandInvitation> {
    return new DIDCommInvitationRunner(str).run();
  }
}

1	import { OutOfBandInvitation } from "./protocols/invitation/v2/OutOfBandInvitation";
2	import {
3	AgentDIDHigherFunctions,
4	AgentInvitations as AgentInvitationsClass,
5	InvitationType,
6	PrismOnboardingInvitation,
7	} from "./types";
8	import {
9	Service as DIDDocumentService,
10	ServiceEndpoint as DIDDocumentServiceEndpoint,
11	Message,
12	} from "../domain";
13	import { AgentError } from "../domain/models/Errors";
14	import {
15	findProtocolTypeByValue,
16	ProtocolType,
17	} from "./protocols/ProtocolTypes";
18	import { Api } from "../domain/models/Api";
19	import { ConnectionsManager } from "./connectionsManager/ConnectionsManager";
20	import { DIDCommConnectionRunner } from "./protocols/connection/DIDCommConnectionRunner";
21	import { Pluto } from "../domain/buildingBlocks/Pluto";
22	import { DIDCommInvitationRunner } from "./protocols/invitation/v2/DIDCommInvitationRunner";
23	import { base64 } from "multiformats/bases/base64";
24
25	/**
26	* An extension for the Edge agent that groups the functionality to parse, manage and
27	* respond to Cloud Agent onboarding and didcomm v2 invitations
28	*
29	* @export
30	* @class AgentInvitations
31	* @typedef {AgentInvitations}
32	*/
33	export class AgentInvitations implements AgentInvitationsClass {
34	/**
35	* Creates an instance of AgentInvitations.
36	*
37	* @constructor
38	* @param {Pluto} pluto
39	* @param {Api} api
40	* @param {AgentDIDHigherFunctions} agentDIDHigherFunctions
41	* @param {ConnectionsManager} connection
42	*/
43	constructor(
44	private pluto: Pluto,
45	private api: Api,
46	private agentDIDHigherFunctions: AgentDIDHigherFunctions,
47	private connection: ConnectionsManager
48	) { }
49
50	private decodeOOB(str: string) {
51	const components = new URL(str);	1✔
52	if (!components) {	1!
NEW UNCOV 53	throw new AgentError.InvalidURLError();	×
54	}
55	const message = components.searchParams.get("_oob")	1✔
56	if (!message) {	1!
NEW 57	throw new AgentError.InvalidURLError();	×
58	}
59	const dataJson = Buffer.from(base64.baseDecode(message)).toString();	1✔
60	const json = JSON.parse(dataJson);	1✔
61	return json	1✔
62	}
63
64	/**
65	* Asyncronously parse an invitation from a valid json string
66	*
67	* @async
68	* @param {string} str
69	* @returns {Promise<InvitationType>}
70	*/
71	async parseInvitation(str: string): Promise<InvitationType> {
72	const url = this.decodeOOB(str);	1✔
73	const messasgeType = url.piuri \|\| url.type;	1✔
74	const typeString = findProtocolTypeByValue(messasgeType);	1✔
75	switch (typeString) {	1!
76	case ProtocolType.PrismOnboarding:
UNCOV 77	return this.parsePrismInvitation(str);	×
78	case ProtocolType.Didcomminvitation:
79	return this.parseOOBInvitation(url);	1✔
80	}
81
UNCOV 82	throw new AgentError.UnknownInvitationTypeError();	×
83	}
84
85	async acceptInvitation(invitation: InvitationType, optionalAlias?: string): Promise<void> {
86	if (invitation.type === ProtocolType.Didcomminvitation) {	1!
87	return this.acceptDIDCommInvitation(invitation, optionalAlias);	1✔
88	}
89
UNCOV 90	if (invitation instanceof PrismOnboardingInvitation) {	×
UNCOV 91	return this.acceptPrismOnboardingInvitation(invitation);	×
92	}
93
UNCOV 94	throw new AgentError.InvitationIsInvalidError();	×
95	}
96
97	/**
98	* Asyncronously accept a didcomm v2 invitation, will create a pair between the Agent
99	* its connecting with and the current owner's did
100	*
101	* @async
102	* @param {OutOfBandInvitation} invitation
103	* @returns {*}
104	*/
105	async acceptDIDCommInvitation(invitation: OutOfBandInvitation, optionalAlias?: string) {
106	if (!this.connection.mediationHandler.mediator) {	1!
UNCOV 107	throw new AgentError.NoMediatorAvailableError();	×
108	}
109	const [attachment] = invitation.attachments ?? [];	1!
110	if (!attachment) {	1!
111	const ownDID = await this.agentDIDHigherFunctions.createNewPeerDID(	1✔
112	[],
113	true
114	);
115	const pair = await new DIDCommConnectionRunner(	1✔
116	invitation,
117	this.pluto,
118	ownDID,
119	this.connection,
120	optionalAlias
121	).run();
122	await this.connection.addConnection(pair);	1✔
123	} else {
UNCOV 124	const ownDID = await this.agentDIDHigherFunctions.createNewPeerDID(	×
125	[],
126	true
127	);
UNCOV 128	const msg = Message.fromJson({	×
129	...attachment.payload,
130	to: ownDID.toString()
131	});
UNCOV 132	await this.pluto.storeMessage(msg)	×
133	}
134	}
135
136	/**
137	* Asyncronously accept an onboarding invitation, used to onboard the current DID in the Cloud Agent.
138	*
139	* @async
140	* @param {PrismOnboardingInvitation} invitation
141	* @returns {Promise<void>}
142	*/
143	async acceptPrismOnboardingInvitation(invitation: PrismOnboardingInvitation): Promise<void> {
UNCOV 144	if (!invitation.from) {	×
145	throw new AgentError.UnknownInvitationTypeError();	×
146	}
147	interface SendDID {
148	did: string;
149	}
UNCOV 150	const body: SendDID = {	×
151	did: invitation.from.toString(),
152	};
UNCOV 153	const response = await this.api.request(	×
154	"POST",
155	invitation.onboardEndpoint,
156	new Map(),
157	new Map(),
158	body
159	);
160	if (response.httpStatus != 200) {	×
161	throw new AgentError.FailedToOnboardError();	×
162	}
163	}
164
165	/**
166	* Asyncronously parse a prismOnboarding invitation from a string
167	*
168	* @async
169	* @param {string} str
170	* @returns {Promise<PrismOnboardingInvitation>}
171	*/
172	async parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation> {
UNCOV 173	try {	×
174	const prismOnboarding =
175	OutOfBandInvitation.parsePrismOnboardingInvitationFromJson(str);	×
UNCOV 176	const url = prismOnboarding.onboardEndpoint;	×
177	const services: DIDDocumentService[] = [	×
178	new DIDDocumentService(
179	"#didcomm-1",
180	["DIDCommMessaging"],
181	new DIDDocumentServiceEndpoint(url, ["DIDCommMessaging"])
182	),
183	];
UNCOV 184	const updateMediator = true;	×
UNCOV 185	const did = await this.agentDIDHigherFunctions.createNewPeerDID(	×
186	services,
187	updateMediator
188	);
UNCOV 189	prismOnboarding.from = did;	×
UNCOV 190	return prismOnboarding;	×
191	} catch (e) {
UNCOV 192	if (e instanceof Error) {	×
UNCOV 193	throw new AgentError.UnknownInvitationTypeError(e.message);	×
194	} else {
UNCOV 195	throw e;	×
196	}
197	}
198	}
199
200	/**
201	* Asyncronously parse an out of band invitation from a URI as the oob come in format of valid URL
202	*
203	* @async
204	* @param {URL} str
205	* @returns {Promise<OutOfBandInvitation>}
206	*/
207	async parseOOBInvitation(str: URL \| object): Promise<OutOfBandInvitation> {
208	return new DIDCommInvitationRunner(str).run();	4✔
209	}
210	}

hyperledger / identus-edge-agent-sdk-ts / 10664806424

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