9417390838

Committed 07 Jun 2024 12:57PM UTC coverage: 69.3% (+1.2%) from 68.144%

Build # 9417390838

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Backup and Restore (#215)

Signed-off-by: Curtis Harding <ch@curtish.me>

Run Details

1087 of 1756 branches covered (61.9%)

Branch coverage included in aggregate %.

218 of 264 new or added lines in 29 files covered. (82.58%)

3 existing lines in 2 files now uncovered.

2290 of 3117 relevant lines covered (73.47%)

19.41 hits per line

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

68.57

/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 { AgentBackup } from "./Agent.Backup";
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;
  public backup: AgentBackup;

  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
    );

    this.backup = new AgentBackup(this);
  }

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

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

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