9283688715

Committed 29 May 2024 09:31AM UTC coverage: 68.129% (-0.6%) from 68.711%

Build # 9283688715

Build Type

Pull #219

github

Committed by

web-flow

Commit Message

Merge 0463cd287 into 9f1f7a3a8

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

Run Details

1019 of 1669 branches covered (61.05%)

Branch coverage included in aggregate %.

147 of 236 new or added lines in 11 files covered. (62.29%)

4 existing lines in 3 files now uncovered.

2102 of 2912 relevant lines covered (72.18%)

15.59 hits per line

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

68.27

/src/edge-agent/Agent.ts

import * as Domain from "../domain";

import Apollo from "../apollo";
import Castor from "../castor";
import Mercury from "../mercury";
import Pollux from "../pollux";

import { ApiImpl } from "./helpers/ApiImpl";

import {
  AgentCredentials as AgentCredentialsClass,
  AgentDIDHigherFunctions as AgentDIDHigherFunctionsClass,
  AgentInvitations as AgentInvitationsClass,
  AgentOptions,
  EventCallback,
  InvitationType,
  ListenerKey,
  MediatorHandler,
  PrismOnboardingInvitation,
} from "./types";

import { AgentCredentials } from "./Agent.Credentials";
import { AgentDIDHigherFunctions } from "./Agent.DIDHigherFunctions";
import { AgentInvitations } from "./Agent.Invitations";
import { ConnectionsManager } from "./connectionsManager/ConnectionsManager";
import { OutOfBandInvitation } from "./protocols/invitation/v2/OutOfBandInvitation";
import { OfferCredential } from "./protocols/issueCredential/OfferCredential";
import { RequestCredential } from "./protocols/issueCredential/RequestCredential";
import { IssueCredential } from "./protocols/issueCredential/IssueCredential";
import { Presentation } from "./protocols/proofPresentation/Presentation";
import { RequestPresentation } from "./protocols/proofPresentation/RequestPresentation";
import { DIDCommWrapper } from "../mercury/didcomm/Wrapper";
import { PublicMediatorStore } from "./mediator/PlutoMediatorStore";
import { BasicMediatorHandler } from "./mediator/BasicMediatorHandler";

enum AgentState {
  STOPPED = "stopped",
  STARTING = "starting",
  RUNNING = "running",
  STOPPING = "stopping",
}

/**
 * Edge agent implementation
 *
 * @export
 * @class Agent
 * @typedef {Agent}
 */
export default class Agent
  implements
  AgentCredentialsClass,
  AgentDIDHigherFunctionsClass,
  AgentInvitationsClass {
  /**
   * Agent state
   *
   * @public
   * @type {AgentState}
   */
  public state: AgentState = AgentState.STOPPED;

  private agentCredentials: AgentCredentials;
  private agentDIDHigherFunctions: AgentDIDHigherFunctions;
  private agentInvitations: AgentInvitations;

  private pollux: Pollux;


  /**
   * Creates an instance of Agent.
   *
   * @constructor
   * @param {Apollo} apollo
   * @param {Castor} castor
   * @param {Pluto} pluto
   * @param {Mercury} mercury
   * @param {MediatorHandler} mediationHandler
   * @param {ConnectionsManager} connectionManager
   * @param {Seed} [seed=apollo.createRandomSeed().seed]
   * @param {Api} [api=new ApiImpl()]
   */
  constructor(
    public readonly apollo: Domain.Apollo,
    public readonly castor: Domain.Castor,
    public readonly pluto: Domain.Pluto,
    public readonly mercury: Domain.Mercury,
    public readonly mediationHandler: MediatorHandler,
    public readonly connectionManager: ConnectionsManager,
    public readonly seed: Domain.Seed = apollo.createRandomSeed().seed,
    public readonly api: Domain.Api = new ApiImpl(),
    options?: AgentOptions
  ) {

    this.pollux = new Pollux(castor);
    this.agentDIDHigherFunctions = new AgentDIDHigherFunctions(
      apollo,
      castor,
      pluto,
      mediationHandler,
      seed
    );

    this.agentCredentials = new AgentCredentials(
      apollo,
      castor,
      pluto,
      this.pollux,
      seed,
      mercury,
      this.agentDIDHigherFunctions
    );

    this.connectionManager =
      connectionManager ||
      new ConnectionsManager(
        castor,
        mercury,
        pluto,
        this.agentCredentials,
        mediationHandler,
        [],
        options
      );

    this.agentInvitations = new AgentInvitations(
      this.pluto,
      this.api,
      this.agentDIDHigherFunctions,
      this.connectionManager
    );
  }

  /**
   * Convenience initializer for Agent
   * allowing default instantiation, omitting all but the absolute necessary parameters
   * 
   * @param {Object} params - dependencies object
   * @param {DID | string} params.mediatorDID - did of the mediator to be used
   * @param {Pluto} params.pluto - storage implementation
   * @param {Api} [params.api]
   * @param {Apollo} [params.apollo]
   * @param {Castor} [params.castor]
   * @param {Mercury} [params.mercury]
   * @param {Seed} [params.seed]
   * @returns {Agent}
   */
  static initialize(params: {
    mediatorDID: Domain.DID | string;
    pluto: Domain.Pluto;
    api?: Domain.Api;
    apollo?: Domain.Apollo;
    castor?: Domain.Castor;
    mercury?: Domain.Mercury;
    seed?: Domain.Seed;
    options?: AgentOptions
  }): Agent {
    const mediatorDID = Domain.DID.from(params.mediatorDID);
    const pluto = params.pluto;

    const api = params.api ?? new ApiImpl();
    const apollo = params.apollo ?? new Apollo();
    const castor = params.castor ?? new Castor(apollo);

    const didcomm = new DIDCommWrapper(apollo, castor, pluto);
    const mercury = params.mercury ?? new Mercury(castor, didcomm, api);

    const store = new PublicMediatorStore(pluto);
    const handler = new BasicMediatorHandler(mediatorDID, mercury, store);
    const pollux = new Pollux(castor);
    const seed = params.seed ?? apollo.createRandomSeed().seed;

    const agentCredentials = new AgentCredentials(
      apollo,
      castor,
      pluto,
      pollux,
      seed,
      mercury,
      new AgentDIDHigherFunctions(
        apollo,
        castor,
        pluto,
        handler,
        seed
      )
    )

    const manager = new ConnectionsManager(castor, mercury, pluto, agentCredentials, handler, [], params.options);

    const agent = new Agent(
      apollo,
      castor,
      pluto,
      mercury,
      handler,
      manager,
      seed,
      api,
      params.options
    );

    return agent;
  }

  /**
   * Get current mediator DID if available or null
   *
   * @public
   * @readonly
   * @type {DID}
   */
  public get currentMediatorDID() {
    return this.mediationHandler.mediator?.mediatorDID;
  }

  /**
   * Mainly for testing purposes but instantiating the Agent from a ConnectionManager directly
   *
   * @static
   * @param {Apollo} apollo
   * @param {Castor} castor
   * @param {Pluto} pluto
   * @param {Mercury} mercury
   * @param {ConnectionsManager} connectionManager
   * @param {?Seed} [seed]
   * @param {?Api} [api]
   * @returns {Agent}
   */
  static instanceFromConnectionManager(
    apollo: Domain.Apollo,
    castor: Domain.Castor,
    pluto: Domain.Pluto,
    mercury: Domain.Mercury,
    connectionManager: ConnectionsManager,
    seed?: Domain.Seed,
    api?: Domain.Api,
    options?: AgentOptions
  ) {
    return new Agent(
      apollo,
      castor,
      pluto,
      mercury,
      connectionManager.mediationHandler,
      connectionManager,
      seed ? seed : apollo.createRandomSeed().seed,
      api ? api : new ApiImpl(),
      options
    );
  }

  /**
   * 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: Domain.Credential, fields: string[], linkSecret: string) {
    return this.agentCredentials.revealCredentialFields(
      credential,
      fields,
      linkSecret
    )
  }


  /**
   * Asyncronously start the agent
   *
   * @async
   * @returns {Promise<AgentState>}
   */
  async start(): Promise<AgentState> {
    if (this.state !== AgentState.STOPPED) {
      return this.state;
    }
    this.state = AgentState.STARTING;
    try {

      await this.pluto.start();

      await this.pollux.start();

      await this.connectionManager.startMediator();

    } catch (e) {
      if (e instanceof Domain.AgentError.NoMediatorAvailableError) {
        const hostDID = await this.createNewPeerDID([], false);

        await this.connectionManager.registerMediator(hostDID);

      } else throw e;
    }

    if (this.connectionManager.mediationHandler.mediator !== undefined) {
      await this.connectionManager.startFetchingMessages(5);
      this.state = AgentState.RUNNING;

    } else {
      throw new Domain.AgentError.MediationRequestFailedError("Mediation failed");

    }

    const storedLinkSecret = await this.pluto.getLinkSecret();
    if (storedLinkSecret == null) {
      const secret = this.pollux.anoncreds.createLinksecret();
      const linkSecret = new Domain.LinkSecret(secret);
      await this.pluto.storeLinkSecret(linkSecret);
    }

    return this.state;
  }

  /**
   * Asyncronously stop the agent and any side task that is running
   *
   * @async
   * @returns {Promise<void>}
   */
  async stop(): Promise<void> {
    if (this.state !== AgentState.RUNNING) {
      return;
    }
    this.state = AgentState.STOPPING;
    this.connectionManager.stopAllEvents();
    this.connectionManager.stopFetchingMessages();
    this.state = AgentState.STOPPED;
  }

  /**
   * Asyncronously create a new PrismDID
   *
   * @async
   * @param {string} alias
   * @param {DIDDocumentService[]} [services=[]]
   * @param {?number} [keyPathIndex]
   * @returns {Promise<DID>}
   */
  async createNewPrismDID(
    alias: string,
    services: Domain.Service[] = [],
    keyPathIndex?: number
  ): Promise<Domain.DID> {
    return this.agentDIDHigherFunctions.createNewPrismDID(
      alias,
      services,
      keyPathIndex
    );
  }

  /**
   * Asyncronously Create a new PeerDID
   *
   * @async
   * @param {DIDDocumentService[]} [services=[]]
   * @param {boolean} [updateMediator=true]
   * @returns {Promise<DID>}
   */
  async createNewPeerDID(
    services: Domain.Service[] = [],
    updateMediator = true
  ): Promise<Domain.DID> {
    return this.agentDIDHigherFunctions.createNewPeerDID(
      services,
      updateMediator
    );
  }

  /**
   * Asyncronously parse an invitation from a valid json string
   *
   * @async
   * @param {string} str
   * @returns {Promise<InvitationType>}
   */
  async parseInvitation(str: string): Promise<InvitationType> {
    return this.agentInvitations.parseInvitation(str);
  }

  /**
   * Handle an invitation to create a connection
   * 
   * @async
   * @param {InvitationType} invitation - an OOB or PrismOnboarding invitation
   * @returns {Promise<void>}
   */
  async acceptInvitation(invitation: InvitationType, optionalAlias?: string): Promise<void> {
    return this.agentInvitations.acceptInvitation(invitation, optionalAlias);
  }

  /**
   * Asyncronously sign a message with a DID
   *
   * @async
   * @param {DID} did
   * @param {Uint8Array} message
   * @returns {Promise<Signature>}
   */
  async signWith(did: Domain.DID, message: Uint8Array): Promise<Domain.Signature> {
    return this.agentDIDHigherFunctions.signWith(did, message);
  }

  /**
   * Asyncronously parse a prismOnboarding invitation from a string
   *
   * @async
   * @param {string} str
   * @returns {Promise<PrismOnboardingInvitation>}
   */
  async parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation> {
    return this.agentInvitations.parsePrismInvitation(str);
  }

  /**
   * 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): Promise<OutOfBandInvitation> {
    return this.agentInvitations.parseOOBInvitation(str);
  }

  /**
   * Asyncronously accept a didcomm v2 invitation, will create a pair between the Agent
   *  its connecting with and the current owner's did
   *
   * @deprecated - use `acceptInvitation`
   * @async
   * @param {OutOfBandInvitation} invitation
   * @returns {*}
   */
  async acceptDIDCommInvitation(
    invitation: OutOfBandInvitation, optionalAlias?: string
  ): Promise<void> {
    return this.agentInvitations.acceptDIDCommInvitation(invitation, optionalAlias);
  }

  /**
   * Start fetching for new messages in such way that it can be stopped at any point in time without causing memory leaks
   *
   * @param {number} iterationPeriod
   */
  async startFetchingMessages(iterationPeriod: number): Promise<void> {
    return this.connectionManager.startFetchingMessages(iterationPeriod);
  }

  /**
   * Stops fetching messages
   */
  stopFetchingMessages(): void {
    this.connectionManager.stopFetchingMessages();
  }

  /**
   * Asyncronously send a didcomm Message
   *
   * @param {Message} message
   * @returns {Promise<Message | undefined>}
   */
  sendMessage(message: Domain.Message): Promise<Domain.Message | undefined> {
    return this.connectionManager.sendMessage(message);
  }

  /**
   * Asyncronously get all verifiable credentials
   *
   * @returns {Promise<Credential[]>}
   */
  verifiableCredentials(): Promise<Domain.Credential[]> {
    return this.agentCredentials.verifiableCredentials();
  }

  /**
   * Add an event listener to get notified from an Event "MESSAGE"
   *
   * @param {ListenerKey} eventName
   * @param {EventCallback} callback
   */
  addListener(eventName: ListenerKey, callback: EventCallback): void {
    return this.connectionManager.events.addListener(eventName, callback);
  }

  /**
   * Remove event listener, used by stop procedure
   * @date 20/06/2023 - 14:31:30
   *
   * @param {ListenerKey} eventName
   * @param {EventCallback} callback
   */
  removeListener(eventName: ListenerKey, callback: EventCallback): void {
    return this.connectionManager.events.removeListener(eventName, callback);
  }

  /**
   * 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> {
    return this.agentCredentials.prepareRequestCredentialWithIssuer(offer);
  }

  /**
   * Extract the verifiableCredential object from the Issue credential message asyncronously
   *
   * @async
   * @param {IssueCredential} message
   * @returns {Promise<VerifiableCredential>}
   */
  async processIssuedCredentialMessage(
    message: IssueCredential
  ): Promise<Domain.Credential> {
    return this.agentCredentials.processIssuedCredentialMessage(message);
  }

  /**
   * 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} request
   * @param {VerifiableCredential} credential
   * @returns {Promise<Presentation>}
   */
  async createPresentationForRequestProof(
    request: RequestPresentation,
    credential: Domain.Credential
  ): Promise<Presentation> {
    return this.agentCredentials.createPresentationForRequestProof(
      request,
      credential
    );
  }


  /**
   * Initiate a PresentationRequest from the SDK, to create oob Verification Requests
   * @param {Domain.CredentialType} type 
   * @param {Domain.DID} toDID 
   * @param {ProofTypes[]} proofTypes[]
   * @returns 
   * 
   * 1. Example use-case: Send a Presentation Request for a JWT credential issued by a specific issuer
   * ```ts
   *  agent.initiatePresentationRequest(
   *    Domain.CredentialType.JWT,
   *    toDID,
   *    { issuer: Domain.DID.fromString("did:peer:12345"), claims: {}}
   * );
   * ```
   * 
   * 2. Example use-case: Send a Presentation Request for a JWT credential issued by a specific issuer and specific claims
   * ```ts
   *  agent.initiatePresentationRequest(
   *    Domain.CredentialType.JWT,
   *    toDID,
   *    { issuer: Domain.DID.fromString("did:peer:12345"), claims: {email: {type: 'string', pattern:'email@email.com'}}}
   * );
   * ```
   */
  async initiatePresentationRequest<T extends Domain.CredentialType = Domain.CredentialType.JWT>(type: T, toDID: Domain.DID, presentationClaims: Domain.PresentationClaims<T>): Promise<RequestPresentation> {
    const requestPresentation = await this.agentCredentials.initiatePresentationRequest(
      type,
      toDID,
      presentationClaims
    );

    const requestPresentationMessage = requestPresentation.makeMessage()
    await this.connectionManager.sendMessage(requestPresentationMessage);
    return requestPresentation
  }

  /**
   * Initiate the Presentation and presentationSubmission
   * @param presentation 
   */
  async handlePresentation<Type extends Domain.CredentialType = Domain.CredentialType.JWT>(presentation: Presentation): Promise<boolean> {
    return this.agentCredentials.handlePresentation<Type>(presentation)
  }

}

1	import * as Domain from "../domain";
2
3	import Apollo from "../apollo";
4	import Castor from "../castor";
5	import Mercury from "../mercury";
6	import Pollux from "../pollux";
7
8	import { ApiImpl } from "./helpers/ApiImpl";
9
10	import {
11	AgentCredentials as AgentCredentialsClass,
12	AgentDIDHigherFunctions as AgentDIDHigherFunctionsClass,
13	AgentInvitations as AgentInvitationsClass,
14	AgentOptions,
15	EventCallback,
16	InvitationType,
17	ListenerKey,
18	MediatorHandler,
19	PrismOnboardingInvitation,
20	} from "./types";
21
22	import { AgentCredentials } from "./Agent.Credentials";
23	import { AgentDIDHigherFunctions } from "./Agent.DIDHigherFunctions";
24	import { AgentInvitations } from "./Agent.Invitations";
25	import { ConnectionsManager } from "./connectionsManager/ConnectionsManager";
26	import { OutOfBandInvitation } from "./protocols/invitation/v2/OutOfBandInvitation";
27	import { OfferCredential } from "./protocols/issueCredential/OfferCredential";
28	import { RequestCredential } from "./protocols/issueCredential/RequestCredential";
29	import { IssueCredential } from "./protocols/issueCredential/IssueCredential";
30	import { Presentation } from "./protocols/proofPresentation/Presentation";
31	import { RequestPresentation } from "./protocols/proofPresentation/RequestPresentation";
32	import { DIDCommWrapper } from "../mercury/didcomm/Wrapper";
33	import { PublicMediatorStore } from "./mediator/PlutoMediatorStore";
34	import { BasicMediatorHandler } from "./mediator/BasicMediatorHandler";
35
36	enum AgentState {
37	STOPPED = "stopped",
38	STARTING = "starting",
39	RUNNING = "running",
40	STOPPING = "stopping",
41	}
42
43	/**
44	* Edge agent implementation
45	*
46	* @export
47	* @class Agent
48	* @typedef {Agent}
49	*/
50	export default class Agent
51	implements
52	AgentCredentialsClass,
53	AgentDIDHigherFunctionsClass,
54	AgentInvitationsClass {
55	/**
56	* Agent state
57	*
58	* @public
59	* @type {AgentState}
60	*/
61	public state: AgentState = AgentState.STOPPED;	30✔
62
63	private agentCredentials: AgentCredentials;
64	private agentDIDHigherFunctions: AgentDIDHigherFunctions;
65	private agentInvitations: AgentInvitations;
66
67	private pollux: Pollux;
68
69
70	/**
71	* Creates an instance of Agent.
72	*
73	* @constructor
74	* @param {Apollo} apollo
75	* @param {Castor} castor
76	* @param {Pluto} pluto
77	* @param {Mercury} mercury
78	* @param {MediatorHandler} mediationHandler
79	* @param {ConnectionsManager} connectionManager
80	* @param {Seed} [seed=apollo.createRandomSeed().seed]
81	* @param {Api} [api=new ApiImpl()]
82	*/
83	constructor(
84	public readonly apollo: Domain.Apollo,
85	public readonly castor: Domain.Castor,
86	public readonly pluto: Domain.Pluto,
87	public readonly mercury: Domain.Mercury,
88	public readonly mediationHandler: MediatorHandler,
89	public readonly connectionManager: ConnectionsManager,
90	public readonly seed: Domain.Seed = apollo.createRandomSeed().seed,	×
91	public readonly api: Domain.Api = new ApiImpl(),	×
92	options?: AgentOptions
93	) {
94
95	this.pollux = new Pollux(castor);	30✔
96	this.agentDIDHigherFunctions = new AgentDIDHigherFunctions(	30✔
97	apollo,
98	castor,
99	pluto,
100	mediationHandler,
101	seed
102	);
103
104	this.agentCredentials = new AgentCredentials(	30✔
105	apollo,
106	castor,
107	pluto,
108	this.pollux,
109	seed,
110	mercury,
111	this.agentDIDHigherFunctions
112	);
113
114	this.connectionManager =	30✔
115	connectionManager \|\|	30!
116	new ConnectionsManager(
117	castor,
118	mercury,
119	pluto,
120	this.agentCredentials,
121	mediationHandler,
122	[],
123	options
124	);
125
126	this.agentInvitations = new AgentInvitations(	30✔
127	this.pluto,
128	this.api,
129	this.agentDIDHigherFunctions,
130	this.connectionManager
131	);
132	}
133
134	/**
135	* Convenience initializer for Agent
136	* allowing default instantiation, omitting all but the absolute necessary parameters
137	*
138	* @param {Object} params - dependencies object
139	* @param {DID \| string} params.mediatorDID - did of the mediator to be used
140	* @param {Pluto} params.pluto - storage implementation
141	* @param {Api} [params.api]
142	* @param {Apollo} [params.apollo]
143	* @param {Castor} [params.castor]
144	* @param {Mercury} [params.mercury]
145	* @param {Seed} [params.seed]
146	* @returns {Agent}
147	*/
148	static initialize(params: {
149	mediatorDID: Domain.DID \| string;
150	pluto: Domain.Pluto;
151	api?: Domain.Api;
152	apollo?: Domain.Apollo;
153	castor?: Domain.Castor;
154	mercury?: Domain.Mercury;
155	seed?: Domain.Seed;
156	options?: AgentOptions
157	}): Agent {
158	const mediatorDID = Domain.DID.from(params.mediatorDID);	2✔
159	const pluto = params.pluto;	2✔
160
161	const api = params.api ?? new ApiImpl();	2✔
162	const apollo = params.apollo ?? new Apollo();	2✔
163	const castor = params.castor ?? new Castor(apollo);	2✔
164
165	const didcomm = new DIDCommWrapper(apollo, castor, pluto);	2✔
166	const mercury = params.mercury ?? new Mercury(castor, didcomm, api);	2✔
167
168	const store = new PublicMediatorStore(pluto);	2✔
169	const handler = new BasicMediatorHandler(mediatorDID, mercury, store);	2✔
170	const pollux = new Pollux(castor);	2✔
171	const seed = params.seed ?? apollo.createRandomSeed().seed;	2✔
172
173	const agentCredentials = new AgentCredentials(	2✔
174	apollo,
175	castor,
176	pluto,
177	pollux,
178	seed,
179	mercury,
180	new AgentDIDHigherFunctions(
181	apollo,
182	castor,
183	pluto,
184	handler,
185	seed
186	)
187	)
188
189	const manager = new ConnectionsManager(castor, mercury, pluto, agentCredentials, handler, [], params.options);	2✔
190
191	const agent = new Agent(	2✔
192	apollo,
193	castor,
194	pluto,
195	mercury,
196	handler,
197	manager,
198	seed,
199	api,
200	params.options
201	);
202
203	return agent;	2✔
204	}
205
206	/**
207	* Get current mediator DID if available or null
208	*
209	* @public
210	* @readonly
211	* @type {DID}
212	*/
213	public get currentMediatorDID() {
214	return this.mediationHandler.mediator?.mediatorDID;	2✔
215	}
216
217	/**
218	* Mainly for testing purposes but instantiating the Agent from a ConnectionManager directly
219	*
220	* @static
221	* @param {Apollo} apollo
222	* @param {Castor} castor
223	* @param {Pluto} pluto
224	* @param {Mercury} mercury
225	* @param {ConnectionsManager} connectionManager
226	* @param {?Seed} [seed]
227	* @param {?Api} [api]
228	* @returns {Agent}
229	*/
230	static instanceFromConnectionManager(
231	apollo: Domain.Apollo,
232	castor: Domain.Castor,
233	pluto: Domain.Pluto,
234	mercury: Domain.Mercury,
235	connectionManager: ConnectionsManager,
236	seed?: Domain.Seed,
237	api?: Domain.Api,
238	options?: AgentOptions
239	) {
240	return new Agent(	28✔
241	apollo,
242	castor,
243	pluto,
244	mercury,
245	connectionManager.mediationHandler,
246	connectionManager,
247	seed ? seed : apollo.createRandomSeed().seed,	28!
248	api ? api : new ApiImpl(),	28!
249	options
250	);
251	}
252
253	/**
254	* This method can be used by holders in order to disclose the value of a Credential
255	* JWT are just encoded plainText
256	* Anoncreds will really need to be disclosed as the fields are encoded.
257	*
258	* @param {Credential} credential
259	* @returns {AttributeType}
260	*/
261	async revealCredentialFields(credential: Domain.Credential, fields: string[], linkSecret: string) {
NEW 262	return this.agentCredentials.revealCredentialFields(	×
263	credential,
264	fields,
265	linkSecret
266	)
267	}
268
269
270	/**
271	* Asyncronously start the agent
272	*
273	* @async
274	* @returns {Promise<AgentState>}
275	*/
276	async start(): Promise<AgentState> {
277	if (this.state !== AgentState.STOPPED) {	28!
278	return this.state;	×
279	}
280	this.state = AgentState.STARTING;	28✔
281	try {	28✔
282
283	await this.pluto.start();	28✔
284
285	await this.pollux.start();	28✔
286
287	await this.connectionManager.startMediator();	28✔
288
289	} catch (e) {
290	if (e instanceof Domain.AgentError.NoMediatorAvailableError) {	×
291	const hostDID = await this.createNewPeerDID([], false);	×
292
293	await this.connectionManager.registerMediator(hostDID);	×
294
295	} else throw e;	×
296	}
297
298	if (this.connectionManager.mediationHandler.mediator !== undefined) {	28!
299	await this.connectionManager.startFetchingMessages(5);	28✔
300	this.state = AgentState.RUNNING;	28✔
301
302	} else {
303	throw new Domain.AgentError.MediationRequestFailedError("Mediation failed");	×
304
305	}
306
307	const storedLinkSecret = await this.pluto.getLinkSecret();	28✔
308	if (storedLinkSecret == null) {	28✔
309	const secret = this.pollux.anoncreds.createLinksecret();	27✔
310	const linkSecret = new Domain.LinkSecret(secret);	27✔
311	await this.pluto.storeLinkSecret(linkSecret);	27✔
312	}
313
314	return this.state;	28✔
315	}
316
317	/**
318	* Asyncronously stop the agent and any side task that is running
319	*
320	* @async
321	* @returns {Promise<void>}
322	*/
323	async stop(): Promise<void> {
324	if (this.state !== AgentState.RUNNING) {	30✔
325	return;	2✔
326	}
327	this.state = AgentState.STOPPING;	28✔
328	this.connectionManager.stopAllEvents();	28✔
329	this.connectionManager.stopFetchingMessages();	28✔
330	this.state = AgentState.STOPPED;	28✔
331	}
332
333	/**
334	* Asyncronously create a new PrismDID
335	*
336	* @async
337	* @param {string} alias
338	* @param {DIDDocumentService[]} [services=[]]
339	* @param {?number} [keyPathIndex]
340	* @returns {Promise<DID>}
341	*/
342	async createNewPrismDID(
343	alias: string,
344	services: Domain.Service[] = [],	2✔
345	keyPathIndex?: number
346	): Promise<Domain.DID> {
347	return this.agentDIDHigherFunctions.createNewPrismDID(	4✔
348	alias,
349	services,
350	keyPathIndex
351	);
352	}
353
354	/**
355	* Asyncronously Create a new PeerDID
356	*
357	* @async
358	* @param {DIDDocumentService[]} [services=[]]
359	* @param {boolean} [updateMediator=true]
360	* @returns {Promise<DID>}
361	*/
362	async createNewPeerDID(
363	services: Domain.Service[] = [],	×
364	updateMediator = true	×
365	): Promise<Domain.DID> {
366	return this.agentDIDHigherFunctions.createNewPeerDID(	1✔
367	services,
368	updateMediator
369	);
370	}
371
372	/**
373	* Asyncronously parse an invitation from a valid json string
374	*
375	* @async
376	* @param {string} str
377	* @returns {Promise<InvitationType>}
378	*/
379	async parseInvitation(str: string): Promise<InvitationType> {
380	return this.agentInvitations.parseInvitation(str);	×
381	}
382
383	/**
384	* Handle an invitation to create a connection
385	*
386	* @async
387	* @param {InvitationType} invitation - an OOB or PrismOnboarding invitation
388	* @returns {Promise<void>}
389	*/
390	async acceptInvitation(invitation: InvitationType, optionalAlias?: string): Promise<void> {
NEW 391	return this.agentInvitations.acceptInvitation(invitation, optionalAlias);	×
392	}
393
394	/**
395	* Asyncronously sign a message with a DID
396	*
397	* @async
398	* @param {DID} did
399	* @param {Uint8Array} message
400	* @returns {Promise<Signature>}
401	*/
402	async signWith(did: Domain.DID, message: Uint8Array): Promise<Domain.Signature> {
403	return this.agentDIDHigherFunctions.signWith(did, message);	×
404	}
405
406	/**
407	* Asyncronously parse a prismOnboarding invitation from a string
408	*
409	* @async
410	* @param {string} str
411	* @returns {Promise<PrismOnboardingInvitation>}
412	*/
413	async parsePrismInvitation(str: string): Promise<PrismOnboardingInvitation> {
414	return this.agentInvitations.parsePrismInvitation(str);	×
415	}
416
417	/**
418	* Asyncronously parse an out of band invitation from a URI as the oob come in format of valid URL
419	*
420	* @async
421	* @param {URL} str
422	* @returns {Promise<OutOfBandInvitation>}
423	*/
424	async parseOOBInvitation(str: URL): Promise<OutOfBandInvitation> {
425	return this.agentInvitations.parseOOBInvitation(str);	2✔
426	}
427
428	/**
429	* Asyncronously accept a didcomm v2 invitation, will create a pair between the Agent
430	* its connecting with and the current owner's did
431	*
432	* @deprecated - use `acceptInvitation`
433	* @async
434	* @param {OutOfBandInvitation} invitation
435	* @returns {*}
436	*/
437	async acceptDIDCommInvitation(
438	invitation: OutOfBandInvitation, optionalAlias?: string
439	): Promise<void> {
440	return this.agentInvitations.acceptDIDCommInvitation(invitation, optionalAlias);	1✔
441	}
442
443	/**
444	* Start fetching for new messages in such way that it can be stopped at any point in time without causing memory leaks
445	*
446	* @param {number} iterationPeriod
447	*/
448	async startFetchingMessages(iterationPeriod: number): Promise<void> {
449	return this.connectionManager.startFetchingMessages(iterationPeriod);	×
450	}
451
452	/**
453	* Stops fetching messages
454	*/
455	stopFetchingMessages(): void {
456	this.connectionManager.stopFetchingMessages();	×
457	}
458
459	/**
460	* Asyncronously send a didcomm Message
461	*
462	* @param {Message} message
463	* @returns {Promise<Message \| undefined>}
464	*/
465	sendMessage(message: Domain.Message): Promise<Domain.Message \| undefined> {
466	return this.connectionManager.sendMessage(message);	×
467	}
468
469	/**
470	* Asyncronously get all verifiable credentials
471	*
472	* @returns {Promise<Credential[]>}
473	*/
474	verifiableCredentials(): Promise<Domain.Credential[]> {
475	return this.agentCredentials.verifiableCredentials();	×
476	}
477
478	/**
479	* Add an event listener to get notified from an Event "MESSAGE"
480	*
481	* @param {ListenerKey} eventName
482	* @param {EventCallback} callback
483	*/
484	addListener(eventName: ListenerKey, callback: EventCallback): void {
485	return this.connectionManager.events.addListener(eventName, callback);	×
486	}
487
488	/**
489	* Remove event listener, used by stop procedure
490	* @date 20/06/2023 - 14:31:30
491	*
492	* @param {ListenerKey} eventName
493	* @param {EventCallback} callback
494	*/
495	removeListener(eventName: ListenerKey, callback: EventCallback): void {
496	return this.connectionManager.events.removeListener(eventName, callback);	×
497	}
498
499	/**
500	* Asyncronously prepare a request credential message from a valid offerCredential for now supporting w3c verifiable credentials offers.
501	*
502	* @async
503	* @param {OfferCredential} offer
504	* @returns {Promise<RequestCredential>}
505	*/
506	async prepareRequestCredentialWithIssuer(
507	offer: OfferCredential
508	): Promise<RequestCredential> {
509	return this.agentCredentials.prepareRequestCredentialWithIssuer(offer);	5✔
510	}
511
512	/**
513	* Extract the verifiableCredential object from the Issue credential message asyncronously
514	*
515	* @async
516	* @param {IssueCredential} message
517	* @returns {Promise<VerifiableCredential>}
518	*/
519	async processIssuedCredentialMessage(
520	message: IssueCredential
521	): Promise<Domain.Credential> {
522	return this.agentCredentials.processIssuedCredentialMessage(message);	10✔
523	}
524
525	/**
526	* Asyncronously create a verifiablePresentation from a valid stored verifiableCredential
527	* This is used when the verified requests a specific verifiable credential, this will create the actual
528	* instance of the presentation which we can share with the verifier.
529	*
530	* @async
531	* @param {RequestPresentation} request
532	* @param {VerifiableCredential} credential
533	* @returns {Promise<Presentation>}
534	*/
535	async createPresentationForRequestProof(
536	request: RequestPresentation,
537	credential: Domain.Credential
538	): Promise<Presentation> {
539	return this.agentCredentials.createPresentationForRequestProof(	7✔
540	request,
541	credential
542	);
543	}
544
545
546	/**
547	* Initiate a PresentationRequest from the SDK, to create oob Verification Requests
548	* @param {Domain.CredentialType} type
549	* @param {Domain.DID} toDID
550	* @param {ProofTypes[]} proofTypes[]
551	* @returns
552	*
553	* 1. Example use-case: Send a Presentation Request for a JWT credential issued by a specific issuer
554	* ```ts
555	* agent.initiatePresentationRequest(
556	* Domain.CredentialType.JWT,
557	* toDID,
558	* { issuer: Domain.DID.fromString("did:peer:12345"), claims: {}}
559	* );
560	* ```
561	*
562	* 2. Example use-case: Send a Presentation Request for a JWT credential issued by a specific issuer and specific claims
563	* ```ts
564	* agent.initiatePresentationRequest(
565	* Domain.CredentialType.JWT,
566	* toDID,
567	* { issuer: Domain.DID.fromString("did:peer:12345"), claims: {email: {type: 'string', pattern:'email@email.com'}}}
568	* );
569	* ```
570	*/
571	async initiatePresentationRequest<T extends Domain.CredentialType = Domain.CredentialType.JWT>(type: T, toDID: Domain.DID, presentationClaims: Domain.PresentationClaims<T>): Promise<RequestPresentation> {
572	const requestPresentation = await this.agentCredentials.initiatePresentationRequest(	×
573	type,
574	toDID,
575	presentationClaims
576	);
577
578	const requestPresentationMessage = requestPresentation.makeMessage()	×
579	await this.connectionManager.sendMessage(requestPresentationMessage);	×
UNCOV 580	return requestPresentation	×
581	}
582
583	/**
584	* Initiate the Presentation and presentationSubmission
585	* @param presentation
586	*/
587	async handlePresentation<Type extends Domain.CredentialType = Domain.CredentialType.JWT>(presentation: Presentation): Promise<boolean> {
NEW 588	return this.agentCredentials.handlePresentation<Type>(presentation)	×
589	}
590
591	}

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

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