@veramo/credential-ld 6.0.1-next.5 → 6.0.1-next.6

package/src/__tests__/issue-verify-ed25519-2020.test.ts

@@ -1,143 +1,143 @@
 import {
-    createAgent,
-    CredentialPayload,
-    ICredentialPlugin,
-    IDIDManager,
-    IIdentifier,
-    IKeyManager,
-    IResolver,
-    TAgent,
-  } from '../../../core/src'
-  import { CredentialPlugin } from '../../../credential-w3c/src'
-  import { DIDManager, MemoryDIDStore } from '../../../did-manager/src'
-  import { KeyManager, MemoryKeyStore, MemoryPrivateKeyStore } from '../../../key-manager/src'
-  import { KeyManagementSystem } from '../../../kms-local/src'
-  import { DIDResolverPlugin } from '../../../did-resolver/src'
-  import { ContextDoc } from '../types'
-  import { CredentialIssuerLD } from '../action-handler'
-  import { LdDefaultContexts } from '../ld-default-contexts'
-  import { VeramoEd25519Signature2020 } from '../suites/Ed25519Signature2020'
-  import { Resolver } from 'did-resolver'
-  import { FakeDidProvider, FakeDidResolver } from '../../../test-utils/src/fake-did'
-  import { jest } from '@jest/globals'
+  createAgent,
+  CredentialPayload,
+  ICredentialPlugin,
+  IDIDManager,
+  IIdentifier,
+  IKeyManager,
+  IResolver,
+  TAgent,
+} from '../../../core/src'
+import { CredentialPlugin } from '../../../credential-w3c/src'
+import { DIDManager, MemoryDIDStore } from '../../../did-manager/src'
+import { KeyManager, MemoryKeyStore, MemoryPrivateKeyStore } from '../../../key-manager/src'
+import { KeyManagementSystem } from '../../../kms-local/src'
+import { DIDResolverPlugin } from '../../../did-resolver/src'
+import { ContextDoc } from '../types'
+import { CredentialProviderLD } from '../CredentialProviderLD'
+import { LdDefaultContexts } from '../ld-default-contexts'
+import { VeramoEd25519Signature2020 } from '../suites/Ed25519Signature2020'
+import { Resolver } from 'did-resolver'
+import { FakeDidProvider, FakeDidResolver } from '../../../test-utils/src/fake-did'
+import { jest } from '@jest/globals'
 
-  jest.setTimeout(300000)
+jest.setTimeout(300000)
 
-  const customContext: Record<string, ContextDoc> = {
-    'custom:example.context': {
-      '@context': {
-        nothing: 'custom:example.context#blank',
-      },
+const customContext: Record<string, ContextDoc> = {
+  'custom:example.context': {
+    '@context': {
+      nothing: 'custom:example.context#blank',
     },
-  }
+  },
+}
 
-  describe('credential-LD full flow', () => {
-    let didFakeIdentifier: IIdentifier
-    let agent: TAgent<IResolver & IKeyManager & IDIDManager & ICredentialPlugin>
+describe('credential-LD full flow', () => {
+  let didFakeIdentifier: IIdentifier
+  let agent: TAgent<IResolver & IKeyManager & IDIDManager & ICredentialPlugin>
 
-    beforeAll(async () => {
-      agent = createAgent({
-        plugins: [
-          new KeyManager({
-            store: new MemoryKeyStore(),
-            kms: {
-              local: new KeyManagementSystem(new MemoryPrivateKeyStore()),
-            },
-          }),
-          new DIDManager({
-            providers: {
-              'did:fake': new FakeDidProvider(),
-            },
-            store: new MemoryDIDStore(),
-            defaultProvider: 'did:fake',
-          }),
-          new DIDResolverPlugin({
-            resolver: new Resolver({
-              ...new FakeDidResolver(() => agent, true).getDidFakeResolver(),
-            }),
-          }),
-          new CredentialPlugin(),
-          new CredentialIssuerLD({
-            contextMaps: [LdDefaultContexts, customContext],
-            suites: [new VeramoEd25519Signature2020()],
-          }),
-        ],
-      })
-      didFakeIdentifier = await agent.didManagerImport({
-        did: 'did:fake:z6MkgbqNU4uF9NKSz5BqJQ4XKVHuQZYcUZP8pXGsJC8nTHwo',
-        keys: [
-          {
-            type: 'Ed25519',
-            kid: 'didcomm-senderKey-1',
-            publicKeyHex: '1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
-            privateKeyHex:
-              'b57103882f7c66512dc96777cbafbeb2d48eca1e7a867f5a17a84e9a6740f7dc1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
-            kms: 'local',
+  beforeAll(async () => {
+    const ld = new CredentialProviderLD({
+      contextMaps: [LdDefaultContexts, customContext],
+      suites: [new VeramoEd25519Signature2020()],
+    })
+    agent = createAgent<IResolver & IKeyManager & IDIDManager & ICredentialPlugin>({
+      plugins: [
+        new KeyManager({
+          store: new MemoryKeyStore(),
+          kms: {
+            local: new KeyManagementSystem(new MemoryPrivateKeyStore()),
           },
-        ],
-        services: [
-          {
-            id: 'msg1',
-            type: 'DIDCommMessaging',
-            serviceEndpoint: 'http://localhost:3002/messaging',
+        }),
+        new DIDManager({
+          providers: {
+            'did:fake': new FakeDidProvider(),
           },
-        ],
-        provider: 'did:fake',
-        alias: 'sender',
-      })
+          store: new MemoryDIDStore(),
+          defaultProvider: 'did:fake',
+        }),
+        new DIDResolverPlugin({
+          resolver: new Resolver({
+            ...new FakeDidResolver(() => agent, true).getDidFakeResolver(),
+          }),
+        }),
+        new CredentialPlugin({ issuers: [ld] }),
+      ],
     })
-
-    it('works with Ed25519Signature2020 credential', async () => {
-      const credential: CredentialPayload = {
-        issuer: didFakeIdentifier.did,
-        '@context': ['custom:example.context'],
-        credentialSubject: {
-          nothing: 'else matters',
+    didFakeIdentifier = await agent.didManagerImport({
+      did: 'did:fake:z6MkgbqNU4uF9NKSz5BqJQ4XKVHuQZYcUZP8pXGsJC8nTHwo',
+      keys: [
+        {
+          type: 'Ed25519',
+          kid: 'didcomm-senderKey-1',
+          publicKeyHex: '1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
+          privateKeyHex:
+            'b57103882f7c66512dc96777cbafbeb2d48eca1e7a867f5a17a84e9a6740f7dc1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
+          kms: 'local',
+        },
+      ],
+      services: [
+        {
+          id: 'msg1',
+          type: 'DIDCommMessaging',
+          serviceEndpoint: 'http://localhost:3002/messaging',
         },
-      }
-      const verifiableCredential = await agent.createVerifiableCredential({
-        credential,
-        proofFormat: 'lds',
-      })
+      ],
+      provider: 'did:fake',
+      alias: 'sender',
+    })
+  })
 
-      expect(verifiableCredential).toBeDefined()
+  it('works with Ed25519Signature2020 credential', async () => {
+    const credential: CredentialPayload = {
+      issuer: didFakeIdentifier.did,
+      '@context': ['custom:example.context'],
+      credentialSubject: {
+        nothing: 'else matters',
+      },
+    }
+    const verifiableCredential = await agent.createVerifiableCredential({
+      credential,
+      proofFormat: 'lds',
+    })
 
-      const result = await agent.verifyCredential({
-        credential: verifiableCredential,
-      })
+    expect(verifiableCredential).toBeDefined()
 
-      expect(result.verified).toBe(true)
+    const result = await agent.verifyCredential({
+      credential: verifiableCredential,
     })
 
-    it('works with Ed25519Signature2020 credential and presentation', async () => {
-      const credential: CredentialPayload = {
-        issuer: didFakeIdentifier.did,
-        '@context': ['custom:example.context'],
-        credentialSubject: {
-          nothing: 'else matters',
-        },
-      }
-      const verifiableCredential1 = await agent.createVerifiableCredential({
-        credential,
-        proofFormat: 'lds',
-      })
+    expect(result.verified).toBe(true)
+  })
 
-      const verifiablePresentation = await agent.createVerifiablePresentation({
-        presentation: {
-          verifiableCredential: [verifiableCredential1],
-          holder: didFakeIdentifier.did,
-        },
-        challenge: 'VERAMO',
-        proofFormat: 'lds',
-      })
+  it('works with Ed25519Signature2020 credential and presentation', async () => {
+    const credential: CredentialPayload = {
+      issuer: didFakeIdentifier.did,
+      '@context': ['custom:example.context'],
+      credentialSubject: {
+        nothing: 'else matters',
+      },
+    }
+    const verifiableCredential1 = await agent.createVerifiableCredential({
+      credential,
+      proofFormat: 'lds',
+    })
 
-      expect(verifiablePresentation).toBeDefined()
+    const verifiablePresentation = await agent.createVerifiablePresentation({
+      presentation: {
+        verifiableCredential: [verifiableCredential1],
+        holder: didFakeIdentifier.did,
+      },
+      challenge: 'VERAMO',
+      proofFormat: 'lds',
+    })
 
-      const result = await agent.verifyPresentation({
-        presentation: verifiablePresentation,
-        challenge: 'VERAMO',
-      })
+    expect(verifiablePresentation).toBeDefined()
 
-      expect(result.verified).toBe(true)
+    const result = await agent.verifyPresentation({
+      presentation: verifiablePresentation,
+      challenge: 'VERAMO',
     })
+
+    expect(result.verified).toBe(true)
   })
+})

package/src/__tests__/{issue-verify-flow.test.ts → issue-verify-flow-ld.test.ts}

@@ -16,7 +16,7 @@ import { getDidKeyResolver, KeyDIDProvider } from '../../../did-provider-key/src
 import { DIDResolverPlugin } from '../../../did-resolver/src'
 import { EthrDIDProvider } from '../../../did-provider-ethr/src'
 import { ContextDoc } from '../types.js'
-import { CredentialIssuerLD } from '../action-handler.js'
+import { CredentialProviderLD } from '../CredentialProviderLD.js'
 import { LdDefaultContexts } from '../ld-default-contexts.js'
 import { VeramoEd25519Signature2018 } from '../suites/Ed25519Signature2018.js'
 import { Resolver } from 'did-resolver'
@@ -43,6 +43,11 @@ describe('credential-LD full flow', () => {
   let didEthrIdentifier: IIdentifier
   let agent: TAgent<IResolver & IKeyManager & IDIDManager & ICredentialPlugin>
 
+  const ld = new CredentialProviderLD({
+    contextMaps: [LdDefaultContexts, customContext],
+    suites: [new VeramoEd25519Signature2018(), new VeramoEcdsaSecp256k1RecoverySignature2020()],
+  })
+
   beforeAll(async () => {
     agent = createAgent<IResolver & IKeyManager & IDIDManager & ICredentialPlugin>({
       plugins: [
@@ -69,11 +74,7 @@ describe('credential-LD full flow', () => {
             ...ethrDidResolver({ infuraProjectId }),
           }),
         }),
-        new CredentialPlugin(),
-        new CredentialIssuerLD({
-          contextMaps: [LdDefaultContexts, customContext],
-          suites: [new VeramoEd25519Signature2018(), new VeramoEcdsaSecp256k1RecoverySignature2020()],
-        }),
+        new CredentialPlugin({ issuers: [ld] }),
       ],
     })
     didKeyIdentifier = await agent.didManagerCreate()

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
- * Provides a {@link @veramo/credential-ld#CredentialIssuerLD | plugin} for the {@link @veramo/core#Agent} that
+ * Provides a {@link @veramo/credential-ld#CredentialProviderLD | handler} for the {@link @veramo/credential-w3c#CredentialPlugin} that
  * implements
- * {@link @veramo/credential-ld#ICredentialIssuerLD} interface.
+ * {@link @veramo/core-types#AbstractCredentialProvider} interface.
  *
  * This plugin adds support for working with JSON-LD credentials.
  * When installed, this plugin will be automatically used by
@@ -10,7 +10,7 @@
  *
  * @packageDocumentation
  */
-export { CredentialIssuerLD } from './action-handler.js'
+export { CredentialProviderLD } from './CredentialProviderLD.js'
 export * from './types.js'
 export { LdDefaultContexts } from './ld-default-contexts.js'
 export { VeramoLdSignature } from './ld-suites.js'
@@ -18,4 +18,3 @@ export * from './suites/EcdsaSecp256k1RecoverySignature2020.js'
 export * from './suites/Ed25519Signature2018.js'
 export * from './suites/Ed25519Signature2020.js'
 export * from './suites/JsonWebSignature2020.js'
-export { schema } from './plugin.schema.js'

package/src/ld-credential-module.ts

@@ -3,6 +3,7 @@ import {
   IAgentContext,
   IKey,
   IResolver,
+  IVerifyResult,
   PresentationPayload,
   UsingResolutionOptions,
   VerifiableCredential,
@@ -22,7 +23,7 @@ const debug = Debug('veramo:w3c:ld-credential-module')
 
 type ForwardedOptions = UsingResolutionOptions & {
   fetchRemoteContexts?: boolean // defaults to false
-  now?: number // defaults to Date.now()
+  now?: Date // defaults to Date.now()
 }
 
 export class LdCredentialModule {
@@ -170,7 +171,7 @@ export class LdCredentialModule {
     credential: VerifiableCredential,
     options: ForwardedOptions,
     context: IAgentContext<IResolver>,
-  ): Promise<boolean> {
+  ): Promise<IVerifyResult> {
     const fetchRemoteContexts = options.fetchRemoteContexts ?? false
     const result = await vc.verifyCredential({
       ...options,
@@ -195,7 +196,7 @@ export class LdCredentialModule {
     domain: string | undefined,
     options: ForwardedOptions,
     context: IAgentContext<IResolver>,
-  ): Promise<boolean> {
+  ): Promise<IVerifyResult> {
     const fetchRemoteContexts = options.fetchRemoteContexts ?? false
     const result = await vc.verify({
       ...options,

package/src/ld-default-contexts.ts

@@ -20,7 +20,7 @@ import schema_org from './contexts/schema.org.json' assert { type: 'json' }
  * Provides a hardcoded map of common Linked Data `@context` definitions.
  *
  * You can use this to bootstrap the `@context` definitions used by
- * {@link @veramo/credential-ld#CredentialIssuerLD | CredentialIssuerLD} with these common context definitions.
+ * {@link @veramo/credential-ld#CredentialProviderLD | CredentialProviderLD} with these common context definitions.
  *
  * @beta This API may change without a BREAKING CHANGE notice.
  */

package/src/ld-suites.ts

@@ -25,6 +25,8 @@ export abstract class VeramoLdSignature {
 
   abstract getSupportedVerificationType(): string | string[]
 
+  abstract getSupportedProofType(): string
+
   abstract getSupportedVeramoKeyType(): TKeyType
 
   abstract getSuiteForSigning(

package/src/suites/EcdsaSecp256k1RecoverySignature2020.ts

@@ -17,6 +17,11 @@ export class VeramoEcdsaSecp256k1RecoverySignature2020 extends VeramoLdSignature
     // 'JsonWebKey2020', 'Multikey']
   }
 
+  getSupportedProofType(): string {
+    return 'EcdsaSecp256k1RecoverySignature2020'
+  }
+
+
   getSupportedVeramoKeyType(): TKeyType {
     return 'Secp256k1'
   }
@@ -71,7 +76,7 @@ export class VeramoEcdsaSecp256k1RecoverySignature2020 extends VeramoLdSignature
     return new EcdsaSecp256k1RecoverySignature2020()
   }
 
-  preSigningCredModification(credential: CredentialPayload): void {}
+  preSigningCredModification(credential: CredentialPayload): void { }
 
   async preDidResolutionModification(didUrl: string, didDoc: DIDDocument): Promise<DIDDocument> {
     const ctx = asArray(didDoc['@context'])

package/src/suites/Ed25519Signature2018.ts

@@ -14,6 +14,11 @@ export class VeramoEd25519Signature2018 extends VeramoLdSignature {
     // TODO: add support for ['Ed25519VerificationKey2020', 'Multikey']
   }
 
+  getSupportedProofType(): string {
+    return 'Ed25519Signature2018'
+  }
+
+
   getSupportedVeramoKeyType(): TKeyType {
     return 'Ed25519'
   }

package/src/suites/Ed25519Signature2020.ts

@@ -35,6 +35,10 @@ export class VeramoEd25519Signature2020 extends VeramoLdSignature {
     // TODO: add support for ['JsonWebKey2020', 'Multikey']
   }
 
+  getSupportedProofType(): string {
+    return 'Ed25519Signature2020'
+  }
+
   getSupportedVeramoKeyType(): TKeyType {
     return 'Ed25519'
   }
@@ -136,7 +140,7 @@ export class VeramoEd25519Signature2020 extends VeramoLdSignature {
 
   private transformVerificationMethod(vm: VerificationMethod): VerificationMethod {
     if (vm.type === 'Ed25519VerificationKey2020') {
-      ;(vm as any)['@context'] = 'https://w3id.org/security/suites/ed25519-2020/v1'
+      ; (vm as any)['@context'] = 'https://w3id.org/security/suites/ed25519-2020/v1'
       // publicKeyMultibase is required by this suite
       if (!vm.publicKeyMultibase) {
         const { publicKeyHex } = extractPublicKeyHex(vm)

package/src/suites/JsonWebSignature2020.ts

@@ -19,7 +19,11 @@ import {
 export class VeramoJsonWebSignature2020 extends VeramoLdSignature {
   getSupportedVerificationType(): string {
     return 'JsonWebKey2020'
-      // TODO: add support for ['Ed25519VerificationKey2018', 'Ed25519VerificationKey2020', 'Multikey'] and others
+    // TODO: add support for ['Ed25519VerificationKey2018', 'Ed25519VerificationKey2020', 'Multikey'] and others
+  }
+
+  getSupportedProofType(): string {
+    return 'JsonWebSignature2020'
   }
 
   getSupportedVeramoKeyType(): TKeyType {