Skip to content

A plugin for the Veramo agent enabling it to leverage various Aries RFCs via DIDComm.

Notifications You must be signed in to change notification settings

spherity/aries-rfcs-veramo-plugin

Repository files navigation

Documentation Aries Plugin

Aries RFCs Veramo Plugin

A DIDComm MessageHandlerPlugin plugin for the Veramo agent enabling it to send and handle DIDComm messages using the Hyperledger AriesRFCs workflows.@spherity/aries-rfcs-veramo-plugin contain message handlers that are based on aries flows and also contains methods that allow the initiation of those Aries Flows.

Supported Flows

  • Did Exchange 0023
  • Issue Credential v2 0453
  • Present Proof v2 0454

Setup

  1. Install this plugin

    npm install --save @spherity/aries-rfcs-veramo-plugin @veramo/message-handler
    
    
  2. Add the plugin to your agent

     import { MessageHandler } from '@veramo/message-handler';
     import {
       IssueCredential0453MessageHandler,
       PresentProof0454MessageHandler,
       DidExchange0023MessageHandler
     } from 'aries-rfcs-veramo-plugin';
     export const veramoAgent = createAgent<VeramoAgent>({
       plugins: [
         new MessageHandler({
           messageHandlers: [
             new DIDCommMessageHandler(),
             new DidExchange0023MessageHandler(trustResolver),
             new IssueCredential0453MessageHandler(
               CreateCredentialCallback(),
               ReceiveCredentialCallback()
             ),
             new PresentProof0454MessageHandler(
               CreatePresentationCallback(),
               VerifyPresentationCallback()
             ),
           ],
         }),
       ],
     });

Usage

MessageHandlers

  • DidExchange0023MessageHandler

    The DidExchange0023MessageHandler supports the Aries RFC 0023 flows. It allows the user to send and handle messages within that specific protocol, it requires a trustresolver instance with a method of checkTrustStatus as a parameter.

    Sample TrustResolver

      export class TrustResolver {
        const trusted = [...]
        async checkTrustStatus(did: string): Promise<boolean> {
          try {
            const trustStatus = trusted.includes(did)
            return trustStatus
          } catch (e) {
            return false;
          }
        }
      }
  • IssueCredential0453MessageHandler The IssueCredential0453MessageHandler supports the Aries RFC 0453 flows. It allows the user to send and handle messages within that specific protocol, it requires callback functions, for Creating a Credential and Receiving a Credential. Create Credential Callback The parameters for the callback for createCredential are credentialData , issuerDid , recipientDid, veramoAgent. The response from the createCredential callback should be a Veramo CreateVerifiableCredential Response. Sample

      public async createCredential(
        credentialData: any,
        issuerDid: string,
        recipientDid: string,
        veramoAgent: VeramoAgent
      ) {
        const createdAt = new Date();
        const expiresAt = credentialData.expirationDate
          ? new Date(credentialData.expirationDate)
          : new Date(createdAt.getTime() + 1000 * 60 * 60 * 24 * 365);
    
        const credentialPayload: CredentialPayload = {
          id: credentialData.credentialId,
          issuer: issuerDid,
          '@context': [...],
          expirationDate: expiresAt.toISOString(),
          issuanceDate: issuesAt.toISOString(),
          credentialSubject: {
            id: recipientDid,
            ...credentialData.data,
          },
        };
    
        vc = await veramoAgent.createVerifiableCredential(
          {
            credential: credentialPayload,
            proofFormat: 'lds',
            now: nowOverride,
          },
          { agent: veramoAgent.agent } as any,
        );
    
        return vc;
      }

    ReceiveCredentialCallback

    The parameters for the callback for receiveCredential are fromDid, credential, message (contains the credential offer message sent by the issuer to receiver). There is no expected response from the receiveCredential .

    Sample

      private async receiveCredential(fromDid: string, credential: any, message: any) {
        const recipientIdentifier = await identifier.findFirst({
          where: {
            did: fromDid,
          },
        });
    
        if (!recipientIdentifier) {
          throw new Error(`Identifier with did<${fromDid}> is not found`);
        }
        // save credential in the database
      }
  • PresentProof0454MessageHandler The PresentProof0454MessageHandler supports the Aries RFC 0454 flows. It allows the user to send messages within that specific protocol, it requires callback functions for Creating a Presentation and Verifying a Presentation. Create Presentation Callback The parameters for the callback for createPresentation are holderDid , veramoAgent, credentialType. The response from the createPresentation callback can be anything from the presentation to the jwt as long .

    Sample

      private async createPresentation(
        holderDid: string,
        credentialType: CredentialType,
        veramoAgent: VeramoAgent
      ) {
    
        const credential = // retrieve credential from the database
        const presentation = await veramoAgent.createVerifiablePresentation(
          {
            presentation: {
              verifiableCredential: [credential as W3CVerifiableCredential],
              holder: holderDid,
            },
            proofFormat: 'jwt',
          },
          {} as any,
        );
    
        return presentation;
      }

    Verify Presentation Callback The parameters for the callback for verifyPresentation are verifiablePresentation , veramoAgent. The response from the verifyPresentation needs to be a boolean otherwise a Problem Report will be sent to the other party. Sample

      private async verifyPresentation(verifiablePresentation: any, veramoAgent: VeramoAgent) {
        const verificationResponse = await veramoAgent.verifyPresentation(
          {
            presentation: verifiablePresentation,
            // We only want to check the signature and its general validity
            // The rest we handle manually to throw the correct OCI error codes
            policies: {
              issuanceDate: false,
              expirationDate: false,
              aud: false,
            },
          },
          {} as any,
        );
    
        return verificationResponse;
      }

Sending Messages

  • Send0023 (Invitation) The method send0023 method of the AriesRFCsPlugin can be used to initiate the Aries RFC 0023 Protocol. It requires an object of type Send0023MessageAttr and IContext (Veramo Context) and returns an an object of type SendRFCsResponse. Sample
      import { AriesRFCsPlugin } from 'aries-rfcs-veramo-plugin';
    
      const ariesPlugin = new AriesRFCsPlugin;
    
      await ariesPlugin.send0023(
        {
          to: //Receiver DID
          from: // Sender DID
        },
        { VeramoContext }
      );
  • Send0453 (Issue Credential) The method send0453 method of the AriesRFCsPlugin can be used to initiate the Aries RFC 0453 Protocol. It requires an object of type Send0453MessageAttr and IContext (Veramo Context) and returns an an object of type SendRFCsResponse. Sample
      import {
        AriesRFCsPlugin,
        MESSAGE_TYPES_0453,
        DIDCommMessagePacking
      } from 'aries-rfcs-veramo-plugin';
    
      const ariesPlugin = new AriesRFCsPlugin;
    
      await ariesPlugin.send0453(
        {
          to: //Receiver DID
          from: // Sender DID
          type: // MESSAGE_TYPES_0453
          packingType: // DIDCommMessagePacking
          message: {
            '@type': // MESSAGE_TYPE_0453
            credentialBody: {...}
          }
        },
        { VeramoContext }
      );
  • Send0454 (Present Proof) The method send0454 method of the AriesRFCsPlugin can be used to initiate the Aries RFC 0454 Protocol. It requires an object of type Send0454MessageAttr and IContext (Veramo Context) and returns an an object of type SendRFCsResponse. Sample
      import {
        AriesRFCsPlugin,
        MESSAGE_TYPES_0454,
        DIDCommMessagePacking
      } from 'aries-rfcs-veramo-plugin';
    
      const ariesPlugin = new AriesRFCsPlugin;
    
      await ariesPlugin.send0454(
        {
          to: //Receiver DID
          from: // Sender DID
          type: // MESSAGE_TYPES_0454
          packingType: // DIDCommMessagePacking
          message: {
            '@type': // MESSAGE_TYPE_0454
          }
        },
        { VeramoContext }
      );

About

A plugin for the Veramo agent enabling it to leverage various Aries RFCs via DIDComm.

Resources

Stars

Watchers

Forks