feat(core): connection-less issuance and verification

README.md

@@ -63,12 +63,12 @@ Some features are not yet supported, but are on our roadmap. Check [the roadmap]
 - ✅ Basic Message Protocol ([RFC 0095](https://github.com/hyperledger/aries-rfcs/blob/master/features/0095-basic-message/README.md))
 - ✅ Indy Credentials (with `did:sov` support)
 - ✅ HTTP Transport
+- ✅ Connection-less Issuance and Verification
 - 🚧 Revocation of Indy Credentials
 - 🚧 Electron
 - 🚧 Mediator Coordination Protocol ([RFC 0211](https://github.com/hyperledger/aries-rfcs/blob/master/features/0211-route-coordination/README.md))
 - 🚧 WebSocket Transport
 - ❌ Browser
-- ❌ Connection-less Issuance and Verification
 - ❌ Issue Credential V2, Present Proof V2, DID Exchange Protocol, Out-Of-Band
 - ❌ W3C Linked Data VCs, BBS+ Signatures
 

src/__tests__/connectionless-credentials.test.ts

@@ -0,0 +1,158 @@
+import { Subject } from 'rxjs'
+
+import { Agent } from '../agent/Agent'
+import {
+  CredentialRecord,
+  CredentialState,
+  CredentialPreview,
+  CredentialPreviewAttribute,
+} from '../modules/credentials'
+
+import {
+  ensurePublicDidIsOnLedger,
+  registerDefinition,
+  registerSchema,
+  SubjectInboundTransporter,
+  SubjectOutboundTransporter,
+  waitForCredentialRecord,
+  genesisPath,
+  getBaseConfig,
+} from './helpers'
+import testLogger from './logger'
+
+const faberConfig = getBaseConfig('Faber connection-less Credentials', {
+  genesisPath,
+})
+
+const aliceConfig = getBaseConfig('Alice connection-less Credentials', {
+  genesisPath,
+})
+
+const credentialPreview = new CredentialPreview({
+  attributes: [
+    new CredentialPreviewAttribute({
+      name: 'name',
+      mimeType: 'text/plain',
+      value: 'John',
+    }),
+    new CredentialPreviewAttribute({
+      name: 'age',
+      mimeType: 'text/plain',
+      value: '99',
+    }),
+  ],
+})
+
+describe('credentials', () => {
+  let faberAgent: Agent
+  let aliceAgent: Agent
+  let credDefId: string
+
+  beforeAll(async () => {
+    const faberMessages = new Subject()
+    const aliceMessages = new Subject()
+
+    faberAgent = new Agent(faberConfig)
+    faberAgent.setInboundTransporter(new SubjectInboundTransporter(faberMessages, aliceMessages))
+    faberAgent.setOutboundTransporter(new SubjectOutboundTransporter(aliceMessages))
+    await faberAgent.init()
+
+    aliceAgent = new Agent(aliceConfig)
+    aliceAgent.setInboundTransporter(new SubjectInboundTransporter(aliceMessages, faberMessages))
+    aliceAgent.setOutboundTransporter(new SubjectOutboundTransporter(faberMessages))
+    await aliceAgent.init()
+
+    const schemaTemplate = {
+      name: `test-schema-${Date.now()}`,
+      attributes: ['name', 'age'],
+      version: '1.0',
+    }
+    const schema = await registerSchema(faberAgent, schemaTemplate)
+
+    const definitionTemplate = {
+      schema,
+      tag: 'TAG',
+      signatureType: 'CL' as const,
+      supportRevocation: false,
+    }
+    const credentialDefinition = await registerDefinition(faberAgent, definitionTemplate)
+    credDefId = credentialDefinition.id
+
+    const publicDid = faberAgent.publicDid?.did
+    await ensurePublicDidIsOnLedger(faberAgent, publicDid!)
+  })
+
+  afterAll(async () => {
+    await faberAgent.closeAndDeleteWallet()
+    await aliceAgent.closeAndDeleteWallet()
+  })
+
+  test('Faber starts with connection-less credential offer to Alice', async () => {
+    testLogger.test('Faber sends credential offer to Alice')
+    // eslint-disable-next-line prefer-const
+    let { offerMessage, credentialRecord: faberCredentialRecord } = await faberAgent.credentials.createOutOfBandOffer({
+      preview: credentialPreview,
+      credentialDefinitionId: credDefId,
+      comment: 'some comment about credential',
+    })
+
+    const credentialRecordPromise = waitForCredentialRecord(aliceAgent, {
+      threadId: faberCredentialRecord.threadId,
+      state: CredentialState.OfferReceived,
+    })
+
+    await aliceAgent.receiveMessage(offerMessage.toJSON())
+
+    testLogger.test('Alice waits for credential offer from Faber')
+    let aliceCredentialRecord = await credentialRecordPromise
+
+    testLogger.test('Alice sends credential request to Faber')
+    aliceCredentialRecord = await aliceAgent.credentials.acceptOffer(aliceCredentialRecord.id)
+
+    testLogger.test('Faber waits for credential request from Alice')
+    faberCredentialRecord = await waitForCredentialRecord(faberAgent, {
+      threadId: aliceCredentialRecord.threadId,
+      state: CredentialState.RequestReceived,
+    })
+
+    testLogger.test('Faber sends credential to Alice')
+    faberCredentialRecord = await faberAgent.credentials.acceptRequest(faberCredentialRecord.id)
+
+    testLogger.test('Alice waits for credential from Faber')
+    aliceCredentialRecord = await waitForCredentialRecord(aliceAgent, {
+      threadId: faberCredentialRecord.threadId,
+      state: CredentialState.CredentialReceived,
+    })
+
+    testLogger.test('Alice sends credential ack to Faber')
+    aliceCredentialRecord = await aliceAgent.credentials.acceptCredential(aliceCredentialRecord.id)
+
+    testLogger.test('Faber waits for credential ack from Alice')
+    faberCredentialRecord = await waitForCredentialRecord(faberAgent, {
+      threadId: faberCredentialRecord.threadId,
+      state: CredentialState.Done,
+    })
+
+    expect(aliceCredentialRecord).toMatchObject({
+      type: CredentialRecord.name,
+      id: expect.any(String),
+      createdAt: expect.any(Date),
+      offerMessage: expect.any(Object),
+      requestMessage: expect.any(Object),
+      metadata: { requestMetadata: expect.any(Object) },
+      credentialId: expect.any(String),
+      state: CredentialState.Done,
+      threadId: expect.any(String),
+    })
+
+    expect(faberCredentialRecord).toMatchObject({
+      type: CredentialRecord.name,
+      id: expect.any(String),
+      createdAt: expect.any(Date),
+      offerMessage: expect.any(Object),
+      requestMessage: expect.any(Object),
+      state: CredentialState.Done,
+      threadId: expect.any(String),
+    })
+  })
+})

src/__tests__/connectionless-proofs.test.ts

@@ -0,0 +1,194 @@
+import type { CredDefId } from 'indy-sdk'
+
+import { Subject } from 'rxjs'
+
+import { Agent } from '../agent/Agent'
+import { CredentialPreview, CredentialPreviewAttribute } from '../modules/credentials'
+import {
+  PredicateType,
+  PresentationPreview,
+  PresentationPreviewAttribute,
+  PresentationPreviewPredicate,
+  ProofState,
+  ProofAttributeInfo,
+  AttributeFilter,
+  ProofPredicateInfo,
+} from '../modules/proofs'
+
+import {
+  ensurePublicDidIsOnLedger,
+  registerDefinition,
+  registerSchema,
+  SubjectInboundTransporter,
+  SubjectOutboundTransporter,
+  genesisPath,
+  waitForProofRecord,
+  getBaseConfig,
+  issueConnectionLessCredential,
+} from './helpers'
+import testLogger from './logger'
+
+const faberConfig = getBaseConfig('Faber connection-less Proofs', { genesisPath })
+const aliceConfig = getBaseConfig('Alice connection-less Proofs', { genesisPath })
+
+const credentialPreview = new CredentialPreview({
+  attributes: [
+    new CredentialPreviewAttribute({
+      name: 'name',
+      mimeType: 'text/plain',
+      value: 'John',
+    }),
+    new CredentialPreviewAttribute({
+      name: 'age',
+      mimeType: 'text/plain',
+      value: '99',
+    }),
+  ],
+})
+
+describe('Present Proof', () => {
+  let faberAgent: Agent
+  let aliceAgent: Agent
+  let credDefId: CredDefId
+  let presentationPreview: PresentationPreview
+
+  beforeAll(async () => {
+    const faberMessages = new Subject()
+    const aliceMessages = new Subject()
+
+    faberAgent = new Agent(faberConfig)
+    faberAgent.setInboundTransporter(new SubjectInboundTransporter(faberMessages, aliceMessages))
+    faberAgent.setOutboundTransporter(new SubjectOutboundTransporter(aliceMessages))
+    await faberAgent.init()
+
+    aliceAgent = new Agent(aliceConfig)
+    aliceAgent.setInboundTransporter(new SubjectInboundTransporter(aliceMessages, faberMessages))
+    aliceAgent.setOutboundTransporter(new SubjectOutboundTransporter(faberMessages))
+    await aliceAgent.init()
+
+    const schemaTemplate = {
+      name: `test-schema-${Date.now()}`,
+      attributes: ['name', 'age'],
+      version: '1.0',
+    }
+    const schema = await registerSchema(faberAgent, schemaTemplate)
+
+    const definitionTemplate = {
+      schema,
+      tag: 'TAG',
+      signatureType: 'CL' as const,
+      supportRevocation: false,
+    }
+    const credentialDefinition = await registerDefinition(faberAgent, definitionTemplate)
+    credDefId = credentialDefinition.id
+
+    const publicDid = faberAgent.publicDid?.did
+    await ensurePublicDidIsOnLedger(faberAgent, publicDid!)
+
+    presentationPreview = new PresentationPreview({
+      attributes: [
+        new PresentationPreviewAttribute({
+          name: 'name',
+          credentialDefinitionId: credDefId,
+          referent: '0',
+          value: 'John',
+        }),
+      ],
+      predicates: [
+        new PresentationPreviewPredicate({
+          name: 'age',
+          credentialDefinitionId: credDefId,
+          predicate: PredicateType.GreaterThanOrEqualTo,
+          threshold: 50,
+        }),
+      ],
+    })
+
+    await issueConnectionLessCredential({
+      issuerAgent: faberAgent,
+      holderAgent: aliceAgent,
+      credentialTemplate: {
+        credentialDefinitionId: credDefId,
+        comment: 'some comment about credential',
+        preview: credentialPreview,
+      },
+    })
+  })
+
+  afterAll(async () => {
+    await faberAgent.closeAndDeleteWallet()
+    await aliceAgent.closeAndDeleteWallet()
+  })
+
+  test('Faber starts with proof requests to Alice', async () => {
+    testLogger.test('Faber sends presentation request to Alice')
+
+    const attributes = {
+      name: new ProofAttributeInfo({
+        name: 'name',
+        restrictions: [
+          new AttributeFilter({
+            credentialDefinitionId: credDefId,
+          }),
+        ],
+      }),
+    }
+
+    const predicates = {
+      age: new ProofPredicateInfo({
+        name: 'age',
+        predicateType: PredicateType.GreaterThanOrEqualTo,
+        predicateValue: 50,
+        restrictions: [
+          new AttributeFilter({
+            credentialDefinitionId: credDefId,
+          }),
+        ],
+      }),
+    }
+
+    // eslint-disable-next-line prefer-const
+    let { proofRecord: faberProofRecord, requestMessage } = await faberAgent.proofs.createOutOfBandRequest({
+      name: 'test-proof-request',
+      requestedAttributes: attributes,
+      requestedPredicates: predicates,
+    })
+
+    const aliceProofRecordPromise = waitForProofRecord(aliceAgent, {
+      threadId: faberProofRecord.threadId,
+      state: ProofState.RequestReceived,
+    })
+
+    await aliceAgent.receiveMessage(requestMessage.toJSON())
+
+    testLogger.test('Alice waits for presentation request from Faber')
+    let aliceProofRecord = await aliceProofRecordPromise
+
+    testLogger.test('Alice accepts presentation request from Faber')
+    const indyProofRequest = aliceProofRecord.requestMessage?.indyProofRequest
+    const retrievedCredentials = await aliceAgent.proofs.getRequestedCredentialsForProofRequest(
+      indyProofRequest!,
+      presentationPreview
+    )
+    const requestedCredentials = aliceAgent.proofs.autoSelectCredentialsForProofRequest(retrievedCredentials)
+    await aliceAgent.proofs.acceptRequest(aliceProofRecord.id, requestedCredentials)
+
+    testLogger.test('Faber waits for presentation from Alice')
+    faberProofRecord = await waitForProofRecord(faberAgent, {
+      threadId: aliceProofRecord.threadId,
+      state: ProofState.PresentationReceived,
+    })
+
+    // assert presentation is valid
+    expect(faberProofRecord.isVerified).toBe(true)
+
+    // Faber accepts presentation
+    await faberAgent.proofs.acceptPresentation(faberProofRecord.id)
+
+    // Alice waits till it receives presentation ack
+    aliceProofRecord = await waitForProofRecord(aliceAgent, {
+      threadId: aliceProofRecord.threadId,
+      state: ProofState.Done,
+    })
+  })
+})