fix: json ld fixes and aca-py interop fixes

packages/core/src/modules/connections/DidExchangeProtocol.ts

@@ -523,64 +523,73 @@ export class DidExchangeProtocol {
     if (message instanceof DidExchangeResponseMessage) {
       const didRotateAttachment = message.didRotate
 
-      if (!didRotateAttachment) {
-        throw new DidExchangeProblemReportError('DID Rotate attachment is missing.', {
-          problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
-        })
-      }
-
-      const jws = didRotateAttachment.data.jws
-
-      if (!jws) {
-        throw new DidExchangeProblemReportError('DID Rotate signature is missing.', {
-          problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
-        })
-      }
+      if (didRotateAttachment) {
+        try {
+          const jws = didRotateAttachment.data.jws
+
+          if (!jws) {
+            throw new DidExchangeProblemReportError('DID Rotate signature is missing.', {
+              problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
+            })
+          }
 
-      if (!didRotateAttachment.data.base64) {
-        throw new CredoError('DID Rotate attachment is missing base64 property for signed did.')
-      }
+          if (!didRotateAttachment.data.base64) {
+            throw new CredoError('DID Rotate attachment is missing base64 property for signed did.')
+          }
 
-      // JWS payload must be base64url encoded
-      const base64UrlPayload = base64ToBase64URL(didRotateAttachment.data.base64)
-      const signedDid = TypedArrayEncoder.fromBase64(base64UrlPayload).toString()
+          // JWS payload must be base64url encoded
+          const base64UrlPayload = base64ToBase64URL(didRotateAttachment.data.base64)
+          const signedDid = TypedArrayEncoder.fromBase64(base64UrlPayload).toString()
 
-      if (signedDid !== message.did) {
-        throw new CredoError(
-          `DID Rotate attachment's did ${message.did} does not correspond to message did ${message.did}`
-        )
-      }
-
-      const { isValid, signerKeys } = await this.jwsService.verifyJws(agentContext, {
-        jws: {
-          ...jws,
-          payload: base64UrlPayload,
-        },
-        jwkResolver: ({ jws: { header } }) => {
-          if (typeof header.kid !== 'string' || !isDid(header.kid, 'key')) {
-            throw new CredoError('JWS header kid must be a did:key DID.')
+          if (signedDid !== message.did) {
+            throw new CredoError(
+              `DID Rotate attachment's did ${message.did} does not correspond to message did ${message.did}`
+            )
           }
 
-          const didKey = DidKey.fromDid(header.kid)
-          return getJwkFromKey(didKey.key)
-        },
-      })
-
-      if (!isValid || !signerKeys.every((key) => invitationKeysBase58?.includes(key.publicKeyBase58))) {
-        throw new DidExchangeProblemReportError(
-          `DID Rotate signature is invalid. isValid: ${isValid} signerKeys: ${JSON.stringify(
-            signerKeys
-          )} invitationKeys:${JSON.stringify(invitationKeysBase58)}`,
-          {
-            problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
+          const { isValid, signerKeys } = await this.jwsService.verifyJws(agentContext, {
+            jws: {
+              ...jws,
+              payload: base64UrlPayload,
+            },
+            jwkResolver: ({ jws: { header } }) => {
+              if (typeof header.kid !== 'string' || !isDid(header.kid, 'key')) {
+                throw new CredoError('JWS header kid must be a did:key DID.')
+              }
+
+              const didKey = DidKey.fromDid(header.kid)
+              return getJwkFromKey(didKey.key)
+            },
+          })
+
+          if (!isValid || !signerKeys.every((key) => invitationKeysBase58?.includes(key.publicKeyBase58))) {
+            throw new DidExchangeProblemReportError(
+              `DID Rotate signature is invalid. isValid: ${isValid} signerKeys: ${JSON.stringify(
+                signerKeys
+              )} invitationKeys:${JSON.stringify(invitationKeysBase58)}`,
+              {
+                problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
+              }
+            )
           }
-        )
+        } catch (e) {
+          this.logger.warn(`Document does not contain didRotate. Error: ${e.message}`)
+        }
       }
     }
 
     // Now resolve the document related to the did (which can be either a public did or an inline did)
     try {
-      return await agentContext.dependencyManager.resolve(DidsApi).resolveDidDocument(message.did)
+      if (message.did.startsWith('did:'))
+        return await agentContext.dependencyManager.resolve(DidsApi).resolveDidDocument(message.did)
+      else {
+        const did = message.didDoc?.getDataAsJson<DidDocument>().id
+        if (!did)
+          throw new DidExchangeProblemReportError('Cannot resolve did', {
+            problemCode: DidExchangeProblemReportReason.ResponseNotAccepted,
+          })
+        return await agentContext.dependencyManager.resolve(DidsApi).resolveDidDocument(did)
+      }
     } catch (error) {
       const problemCode =
         message instanceof DidExchangeRequestMessage

packages/core/src/modules/credentials/protocol/v2/messages/V2OfferCredentialMessage.ts

@@ -58,6 +58,7 @@ export class V2OfferCredentialMessage extends AgentMessage {
 
   @Expose({ name: 'credential_preview' })
   @Type(() => V2CredentialPreview)
+  @IsOptional()
   @ValidateNested()
   @IsInstance(V2CredentialPreview)
   public credentialPreview?: V2CredentialPreview

packages/core/src/modules/dids/domain/verificationMethod/Bls12381G1Key2020.ts

@@ -32,9 +32,17 @@ export function isBls12381G1Key2020(verificationMethod: VerificationMethod): ver
  * Get a key from a Bls12381G1Key2020 verification method.
  */
 export function getKeyFromBls12381G1Key2020(verificationMethod: Bls12381G1Key2020) {
-  if (!verificationMethod.publicKeyBase58) {
-    throw new CredoError('verification method is missing publicKeyBase58')
+  if (verificationMethod.publicKeyBase58) {
+    return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Bls12381g1)
+  }
+  if (verificationMethod.publicKeyMultibase) {
+    const key = Key.fromFingerprint(verificationMethod.publicKeyMultibase)
+    if (key.keyType === KeyType.Bls12381g1) return key
+    else
+      throw new CredoError(
+        `Unexpected key type from resolving multibase encoding, key type was ${key.keyType} but expected ${KeyType.Bls12381g1}}`
+      )
   }
 
-  return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Bls12381g1)
+  throw new CredoError('verification method is missing publicKeyBase58')
 }

packages/core/src/modules/dids/domain/verificationMethod/Bls12381G2Key2020.ts

@@ -32,9 +32,17 @@ export function isBls12381G2Key2020(verificationMethod: VerificationMethod): ver
  * Get a key from a Bls12381G2Key2020 verification method.
  */
 export function getKeyFromBls12381G2Key2020(verificationMethod: Bls12381G2Key2020) {
-  if (!verificationMethod.publicKeyBase58) {
-    throw new CredoError('verification method is missing publicKeyBase58')
+  if (verificationMethod.publicKeyBase58) {
+    return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Bls12381g2)
+  }
+  if (verificationMethod.publicKeyMultibase) {
+    const key = Key.fromFingerprint(verificationMethod.publicKeyMultibase)
+    if (key.keyType === KeyType.Bls12381g2) return key
+    else
+      throw new CredoError(
+        `Unexpected key type from resolving multibase encoding, key type was ${key.keyType} but expected ${KeyType.Bls12381g2}}`
+      )
   }
 
-  return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Bls12381g2)
+  throw new CredoError('verification method is missing publicKeyBase58')
 }

packages/core/src/modules/dids/domain/verificationMethod/EcdsaSecp256k1VerificationKey2019.ts

@@ -43,9 +43,17 @@ export function isEcdsaSecp256k1VerificationKey2019(
  * Get a key from a EcdsaSecp256k1VerificationKey2019 verification method.
  */
 export function getKeyFromEcdsaSecp256k1VerificationKey2019(verificationMethod: EcdsaSecp256k1VerificationKey2019) {
-  if (!verificationMethod.publicKeyBase58) {
-    throw new CredoError('verification method is missing publicKeyBase58')
+  if (verificationMethod.publicKeyBase58) {
+    return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.K256)
+  }
+  if (verificationMethod.publicKeyMultibase) {
+    const key = Key.fromFingerprint(verificationMethod.publicKeyMultibase)
+    if (key.keyType === KeyType.K256) return key
+    else
+      throw new CredoError(
+        `Unexpected key type from resolving multibase encoding, key type was ${key.keyType} but expected ${KeyType.K256}}`
+      )
   }
 
-  return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.K256)
+  throw new CredoError('verification method is missing publicKeyBase58')
 }

packages/core/src/modules/dids/domain/verificationMethod/Ed25519VerificationKey2018.ts

@@ -34,9 +34,17 @@ export function isEd25519VerificationKey2018(
  * Get a key from a Ed25519VerificationKey2018 verification method.
  */
 export function getKeyFromEd25519VerificationKey2018(verificationMethod: Ed25519VerificationKey2018) {
-  if (!verificationMethod.publicKeyBase58) {
-    throw new CredoError('verification method is missing publicKeyBase58')
+  if (verificationMethod.publicKeyBase58) {
+    return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Ed25519)
+  }
+  if (verificationMethod.publicKeyMultibase) {
+    const key = Key.fromFingerprint(verificationMethod.publicKeyMultibase)
+    if (key.keyType === KeyType.Ed25519) return key
+    else
+      throw new CredoError(
+        `Unexpected key type from resolving multibase encoding, key type was ${key.keyType} but expected ${KeyType.Ed25519}`
+      )
   }
 
-  return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.Ed25519)
+  throw new CredoError('verification method is missing publicKeyBase58')
 }

packages/core/src/modules/dids/domain/verificationMethod/X25519KeyAgreementKey2019.ts

@@ -34,9 +34,17 @@ export function isX25519KeyAgreementKey2019(
  * Get a key from a X25519KeyAgreementKey2019 verification method.
  */
 export function getKeyFromX25519KeyAgreementKey2019(verificationMethod: X25519KeyAgreementKey2019) {
-  if (!verificationMethod.publicKeyBase58) {
-    throw new CredoError('verification method is missing publicKeyBase58')
+  if (verificationMethod.publicKeyBase58) {
+    return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.X25519)
+  }
+  if (verificationMethod.publicKeyMultibase) {
+    const key = Key.fromFingerprint(verificationMethod.publicKeyMultibase)
+    if (key.keyType === KeyType.X25519) return key
+    else
+      throw new CredoError(
+        `Unexpected key type from resolving multibase encoding, key type was ${key.keyType} but expected ${KeyType.X25519}`
+      )
   }
 
-  return Key.fromPublicKeyBase58(verificationMethod.publicKeyBase58, KeyType.X25519)
+  throw new CredoError('verification method is missing publicKeyBase58')
 }

packages/core/src/modules/dids/methods/peer/didPeer.ts

@@ -3,7 +3,7 @@ import { CredoError } from '../../../../error'
 import { getAlternativeDidsForNumAlgo4Did } from './peerDidNumAlgo4'
 
 const PEER_DID_REGEX = new RegExp(
-  '^did:peer:(([01](z)([1-9a-km-zA-HJ-NP-Z]{5,200}))|(2((.[AEVID](z)([1-9a-km-zA-HJ-NP-Z]{5,200}))+(.(S)[0-9a-zA-Z=]*)?))|([4](z[1-9a-km-zA-HJ-NP-Z]{46})(:z[1-9a-km-zA-HJ-NP-Z]{6,}){0,1}))$'
+  '^did:peer:(([01](z)([1-9a-km-zA-HJ-NP-Z]{5,200}))|(2((.[AEVID](z)([1-9a-km-zA-HJ-NP-Z]{5,200}))+(.(S)[0-9a-zA-Z=]*)*))|([4](z[1-9a-km-zA-HJ-NP-Z]{46})(:z[1-9a-km-zA-HJ-NP-Z]{6,}){0,1}))$'
 )
 
 export function isValidPeerDid(did: string): boolean {

packages/core/src/modules/dids/methods/peer/peerDidNumAlgo2.ts

@@ -69,10 +69,13 @@ export function didToNumAlgo2DidDocument(did: string) {
       for (let service of services) {
         // Expand abbreviations used for service key/values
         service = expandServiceAbbreviations(service)
-
         service.id = `${did}#${service.type.toLowerCase()}-${serviceIndex++}`
-
-        didDocument.addService(JsonTransformer.fromJSON(service, DidDocumentService))
+        try {
+          didDocument.addService(JsonTransformer.fromJSON(service, DidDocumentService))
+        } catch (e) {
+          //Ignore a service if we do not recognize it
+          serviceIndex--
+        }
       }
     }
     // Otherwise we can be sure it is a key

packages/core/src/modules/dif-presentation-exchange/DifPresentationExchangeService.ts

@@ -592,7 +592,7 @@ export class DifPresentationExchangeService {
       for (const inputDescriptor of pd.input_descriptors) {
         for (const schema of inputDescriptor.schema) {
           w3cQuery.push({
-            $or: [{ expandedType: [schema.uri] }, { contexts: [schema.uri] }, { type: [schema.uri] }],
+            $or: [{ expandedTypes: [schema.uri] }, { contexts: [schema.uri] }, { types: [schema.uri] }],
           })
         }
       }

packages/core/src/modules/vc/data-integrity/W3cJsonLdCredentialService.ts

@@ -15,7 +15,7 @@ import { createWalletKeyPairClass } from '../../../crypto/WalletKeyPair'
 import { CredoError } from '../../../error'
 import { injectable } from '../../../plugins'
 import { asArray, JsonTransformer } from '../../../utils'
-import { VerificationMethod } from '../../dids'
+import { DidsApi, VerificationMethod } from '../../dids'
 import { getKeyFromVerificationMethod } from '../../dids/domain/key-type'
 import { W3cCredentialsModuleConfig } from '../W3cCredentialsModuleConfig'
 import { w3cDate } from '../util'
@@ -339,12 +339,23 @@ export class W3cJsonLdCredentialService {
     agentContext: AgentContext,
     verificationMethod: string
   ): Promise<Key> {
-    const documentLoader = this.w3cCredentialsModuleConfig.documentLoader(agentContext)
-    const verificationMethodObject = await documentLoader(verificationMethod)
-    const verificationMethodClass = JsonTransformer.fromJSON(verificationMethodObject.document, VerificationMethod)
-
-    const key = getKeyFromVerificationMethod(verificationMethodClass)
-    return key
+    if (!verificationMethod.startsWith('did:peer')) {
+      const documentLoader = this.w3cCredentialsModuleConfig.documentLoader(agentContext)
+      const verificationMethodObject = await documentLoader(verificationMethod)
+      const verificationMethodClass = JsonTransformer.fromJSON(verificationMethodObject.document, VerificationMethod)
+
+      const key = getKeyFromVerificationMethod(verificationMethodClass)
+      return key
+    } else {
+      const [did, keyid] = verificationMethod.split('#')
+      const didsApi = agentContext.dependencyManager.resolve(DidsApi)
+      const doc = await didsApi.resolve(did)
+      if (doc.didDocument) {
+        const verificationMethodClass = doc.didDocument.dereferenceKey(keyid)
+        return getKeyFromVerificationMethod(verificationMethodClass)
+      }
+      throw new CredoError(`Could not resolve verification method with id ${verificationMethod}`)
+    }
   }
 
   private getSignatureSuitesForCredential(agentContext: AgentContext, credential: W3cJsonLdVerifiableCredential) {