Communicaton between Veramo agent and credential exchange

[andra961]

Hi everyone, i noticed that(if i'm not mistaken) in the documentation there aren't guides when it comes to instaurate communication between agents. My goal is to develop a prototype of credential exchange between an issuer and a holder(probably with veramo react native) by using for example qr codes. Would it be possible with the current state of the framework? and from where should i start implementing it?any help would be greatly appreciated, thx in advance.

[mirceanis]

You are right, we don't have an example of end to end communication between agents. This is mostly because there is no one size fits all solution that we could present as the default.

Option 1: DIDComm
Since Veramo deals with DIDs, the natural communication channel between DIDs is through DIDComm (@veramo/did-comm), however there are caveats.
The DID documents of the agents involved (at the very least, the receiver DID) need to contain 2 things. An X25519 keyAgreement key and a DIDCommMessaging endpoint.
Also, the receiving agent needs to listen to messages sent to that endpoint to get the messages.
To get an idea of how this looks like in code, there is a sample in the integration test suite where an agent sends a message to itself between 2 DIDs controlled locally.

If you use did:web, this comes mostly out of the box in veramo. You still need to configure the hostname, though.

Option 2+: A custom protocol
To establish a communication channel, you would likely have the sender find out how and where to send something.
For that to work you could, for example, have the receiver generate some channel information and present that as a QR code.
To get started, it can be as simple as a URL where the sender can send HTTP POST messages.
This can already be done using @veramo/remote-server
This creates an expressjs HTTP POST router that pipes the message into veramo's handleMessage() logic.

Other options are possible too, but they require a lot more work than can be detailed here.

• use WalletConnect
• use libp2p
• use some centralized service like firebase
• ...

In any case, you need a few things:

• receiver advertising where it's listening (and maybe also an encryption key). In the case of @veramo/remote-server, for example, that's just knowing the URL of the server.
• a messageHandler plugin used with the @veramo/message-handler to make sense of the incoming package. If your messages are plain credentials or presentations, then you don't need to do anything, actually. Veramo already supports receiving direct VC/VP payloads.
• some logic on the sender side to encode/encrypt the stuff to be sent.

I'm stopping now before going too deep in the rabbit hole. Perhaps you can share more details about your constraints I can guide you to more relevant answers.
I hope this helps

[mirceanis]

That's great news.
On the sender side, you can avoid using key agreement keys by packing your messages with anoncrypt instead of authcrypt.
Or, just to get your endpoints setup you can use plaintext messages at first.

The veramo DIDComm implementation can automatically transform Ed25519 signing keys into X25519 encryption keys (for keyAgreement).
This sample here uses Ed25519 keys in the receiving DID document.
The same flow should work with did:ethr.
If it does not, then we have bugs to fix :)

Edit: I fixed the wrong link in my answer

[andra961]

Unfortunately, it's not working. I added Ed25519 keys on both receiver and sender with agent.keyManagerCreate as in your example, followed by agent.didManagerAddKey. When i resolve the documents i can see them in verificationMethod like this:
{
id: 'did:ethr.........',
type: 'Ed25519VerificationKey2018',
controller: 'did:ethr.........',
publicKeyHex: 'publickey....'
}
,
but still i get the message Error: key_not_found: could not map an agent key to an skid for did:ethr.

I also tried different packings:

1)packing: "none": i get the following error => ```
Error: Cannot send DIDComm message through transport with id: 'id': Error: Error when sending DIDComm message through transport with
id: 'id': failed to send message: FetchError: request to http://localhost:3002/messaging failed, reason: connect ECONNREFUSED 127.0.0.1:3002

2)packing: "anoncrypt": i get the following error =>
TypeError: Cannot read property 'alg' of undefined
at createJWE (project_path\node_modules@veramo\did-comm\node_modules\did-jwt\src\JWE.ts:98:21)

Hope this helps

[mirceanis]

Can you try to post a receiver DID document as you resolve it?

I think error 1) is indicating a problem with the setup.
error 2) is probably related to the key_not_found message and is likely a problem with Veramo.

In all cases, it's much easier to work with code than to imagine how your setup looks like; so it's helpful if you have a project you can link to.

[andra961]

The didDocument of the receiver looks like this:

{
  didDocumentMetadata: { versionId: '13103712', updated: '2021-11-08T09:26:03Z' },
  didResolutionMetadata: { contentType: 'application/did+ld+json' },
  didDocument: {
    '@context': [
      'https://www.w3.org/ns/did/v1',
      'https://identity.foundation/EcdsaSecp256k1RecoverySignature2020/lds-ecdsa-secp256k1-recovery2020-0.0.jsonld'
    ],
    id: 'did:ethr:...',
    verificationMethod: [
      {
        id: 'did:ethr:...#controller',
        type: 'EcdsaSecp256k1RecoveryMethod2020',
        controller: 'did:ethr:...',
        blockchainAccountId: 'address of the current owner, since i changed owner once'
      },
      {
        id: 'did:ethr:#delegate-1',
        type: 'gianni(this was just for testing addKey()',
        controller: 'did:ethr:..."
        publicKeyHex: 'publicKeyHex'
      },
      {
        id: 'did:ethr:...#delegate-6',
        type: 'Ed25519VerificationKey2018',
        controller: 'did:ethr:...',
        publicKeyHex: 'public key hex'
      }
    ],
    authentication: [
      'did:ethr:...#controller'
    ],
    assertionMethod: [
      'did:ethr:...#controller',
      'did:ethr:...#delegate-1',
      'did:ethr:...#delegate-6'
    ],
    service: [
      {
        id: 'did:ethr:...#service-1',
        type: 'pippo(again, just testing addService())',
        serviceEndpoint: 'Giacomo\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
      },
      {
        id: 'did:ethr:...#service-3',
        type: 'DIDCommMessaging',
        serviceEndpoint: 'http://localhost:3002/messaging'
      }
    ]
  }
}

For the project itself as for now is really just the node tutorial of the documentation to which i imported 2 eth did with private keys through didManagerImport(), added endpoints to them and keys as you can see in the didDocument, and tried to use didComm out of the box.

Also, as you can see, the resolved document is omitting some services(service-2) and keys i added to it previously, i wonder why.

[mirceanis]

I think I see the problem now (or at least one problem).
The @veramo/did-provider-ethr is not adding any keys to the keyAgreement section here.
I think this can be fixed, but in the meantime please try to run your tests with packing: 'none' to see if your endpoints are added properly for the agents to communicate in cleartext.

[andra961]

Unfortunately, it seems they are not:

Error: Cannot send DIDComm message through transport with id: '906acdd8-5db2-4a59-a1f6-e81e6bd4a33a': Error: Error when sending DIDComm message through transport with
id: '906acdd8-5db2-4a59-a1f6-e81e6bd4a33a': failed to send message: FetchError: request to http://localhost:3002/messaging failed, reason: connect ECONNREFUSED 127.0.0.1:3002

Here's the didComm code i'm using:

const message = {
        type: 'test',
        to: receiver.did,
        from: sender.did,
        id: 'test',
        body: { hello: 'world' },
      }

      const packedMessage = await agent.packDIDCommMessage({
        packing: "none",
        message,
      })
      const result = await agent.sendDIDCommMessage({
        messageId: '123',
        packedMessage,
        recipientDidUrl: receiver.did,
      })

[andra961]

so you fixed the keyAgreement bug?congratulations! About the remote-client i was wondering. First, i notice that in order to plug the client agent to the server one you need its schema, which you already possess locally in the integration test. But how could you access it remotely in a real scenario? Secondly, i was wondering if the client agent also triggers the events which fire on the server one( example, messagge received with access to the message body too) In that case, i think it would be possible to have a remote express agent built for listening to incoming messagges, and a client one on React Native which also receives them through said events, shows them to the user and then he decides how to react to them( example: store the incoming credential or discard it). What do you think?

[mirceanis]

The schema json can be posted by the server agent at a known URL, using ApiSchemaRouter. There is an example of this in the package docs.
The client can then use the schema json posted by the server.

In the current version events don't propagate back to the client unfortunately. The client does not hold a connection to the server after a method executes, so the server wouldn't know where to send the events.
With this limitation in mind, perhaps a simpler model is to have the server store all messages, and the client can poll for new messages when it comes online, or periodically.

Also, you are not limited by the capabilities of Veramo. For example, you can create your own websocket connection between your react-native app and the server app. The server app can listen to veramo events (like incoming messages) and post them to the websocket. Then, when your react-native app gets an event on the socket, it can react to it locally.

[andra961]

Again, thank you for the exhaustive answes. I'll let you know if i have other doubts.

[mirceanis]

You're welcome.
I encourage you to tell us more about your project.
There is a Show and Tell section in the discussions that is perfect for this ;)

[vijay05155]

Hi everyone, i want to ask something related to '@veramo/remote-server' this lib.

i was hosted a server using this code that was mention in veramo.io,

import express from 'express'
import { agent } from './agent'
import { AgentRouter, ApiSchemaRouter, WebDidDocRouter } from '@veramo/remote-server'

const getAgentForRequest = async (req: express.Request) => agent
const exposedMethods = agent.availableMethods()
const basePath = '/agent'
const schemaPath = '/open-api.json'

const agentRouter = AgentRouter({
getAgentForRequest,
exposedMethods,
})

const schemaRouter = ApiSchemaRouter({
basePath,
getAgentForRequest,
exposedMethods,
})

const didDocRouter = WebDidDocRouter({
getAgentForRequest,
})

const app = express()
app.use(basePath, agentRouter)
app.use(schemaPath, schemaRouter)
app.use(didDocRouter)
app.listen(3002),

but when i try to use "http://localhost:3002/open-api.json" this address in postman i got , "agent not avilable" in response, can you please help me.