5286569716

Committed 16 Jun 2023 05:33AM UTC coverage: 27.472% (+0.4%) from 27.056%

Build Type

Committed by

Commit Message

chore: improve error message when WALLET_SEED parsing fail

Pull Request Pull Request #543: feat(prism-agent): integrate DID secret storage with Vault

Run Details

117 of 117 new or added lines in 11 files covered. (100.0%)

2484 of 9042 relevant lines covered (27.47%)

0.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.86

/castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/w3c/W3CModelHelper.scala

package io.iohk.atala.castor.core.model.did.w3c

import io.iohk.atala.castor.core.model.did.{
  DIDData,
  DIDMetadata,
  PrismDID,
  PublicKey,
  PublicKeyData,
  Service,
  VerificationRelationship
}
import io.iohk.atala.shared.models.HexString

object W3CModelHelper extends W3CModelHelper

private[castor] trait W3CModelHelper {

  extension (didMetadata: DIDMetadata) {
    def toW3C(did: PrismDID): DIDDocumentMetadataRepr = DIDDocumentMetadataRepr(
      deactivated = didMetadata.deactivated,
      canonicalId = did.asCanonical.toString,
      versionId = HexString.fromByteArray(didMetadata.lastOperationHash.toArray).toString
    )
  }

  extension (didData: DIDData) {
    def toW3C(did: PrismDID): DIDDocumentRepr = {
      import VerificationRelationship.*
      val embeddedKeys = didData.publicKeys.map(k => k.toW3C(did, did))
      val keyRefWithPurpose = didData.publicKeys.map(k => k.purpose -> s"${did.toString}#${k.id}")
      val services = didData.services.map(_.toW3C(did))
      DIDDocumentRepr(
        id = did.toString,
        controller = did.toString,
        verificationMethod = embeddedKeys,
        authentication = keyRefWithPurpose.collect { case (Authentication, k) => k },
        assertionMethod = keyRefWithPurpose.collect { case (AssertionMethod, k) => k },
        keyAgreement = keyRefWithPurpose.collect { case (KeyAgreement, k) => k },
        capabilityInvocation = keyRefWithPurpose.collect { case (CapabilityInvocation, k) => k },
        capabilityDelegation = keyRefWithPurpose.collect { case (CapabilityDelegation, k) => k },
        service = services,
        context = deriveContext(embeddedKeys, services)
      )
    }

    // Reference: https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#constructing-a-json-ld-did-document
    private def deriveContext(keys: Seq[PublicKeyRepr], services: Seq[ServiceRepr]): Seq[String] = {
      val mandatoryContext = Seq("https://www.w3.org/ns/did/v1")
      val additionalContext = {
        val keyTypes = keys.map(_.`type`).toSet
        val serviceTypes = services.map(_.`type`).toSet
        Seq(
          Option.when(keyTypes.contains("JsonWebKey2020"))("https://w3id.org/security/suites/jws-2020/v1"),
          Option.when(serviceTypes.contains("DIDCommMessaging"))("https://didcomm.org/messaging/contexts/v2"),
          Option.when(serviceTypes.contains("LinkedDomains"))(
            "https://identity.foundation/.well-known/did-configuration/v1"
          )
        ).flatten
      }
      val userDefinedContext = didData.context
      mandatoryContext ++ additionalContext ++ userDefinedContext
    }
  }

  extension (service: Service) {
    def toW3C(did: PrismDID): ServiceRepr = ServiceRepr(
      id = s"${did.toString}#${service.id}",
      `type` = service.`type`.name,
      serviceEndpoint = service.serviceEndpoint.map(_.toString)
    )
  }

  extension (publicKey: PublicKey) {
    def toW3C(did: PrismDID, controller: PrismDID): PublicKeyRepr = PublicKeyRepr(
      id = s"${did.toString}#${publicKey.id}",
      `type` = "EcdsaSecp256k1VerificationKey2019",
      controller = controller.toString,
      publicKeyJwk = publicKey.publicKeyData match {
        case PublicKeyData.ECKeyData(crv, x, y) =>
          PublicKeyJwk(
            kty = "EC",
            crv = crv.name,
            x = x.toStringNoPadding,
            y = y.toStringNoPadding
          )
        case pk: PublicKeyData.ECCompressedKeyData =>
          val uncompressed = pk.toUncompressedKeyData
          PublicKeyJwk(
            kty = "EC",
            crv = uncompressed.crv.name,
            x = uncompressed.x.toStringNoPadding,
            y = uncompressed.y.toStringNoPadding
          )
      }
    )
  }

}

1	package io.iohk.atala.castor.core.model.did.w3c
2
3	import io.iohk.atala.castor.core.model.did.{
4	DIDData,
5	DIDMetadata,
6	PrismDID,
7	PublicKey,
8	PublicKeyData,
9	Service,
10	VerificationRelationship
11	}
12	import io.iohk.atala.shared.models.HexString
13
14	object W3CModelHelper extends W3CModelHelper
15
16	private[castor] trait W3CModelHelper {
17
18	extension (didMetadata: DIDMetadata) {	×
19	def toW3C(did: PrismDID): DIDDocumentMetadataRepr = DIDDocumentMetadataRepr(
20	deactivated = didMetadata.deactivated,	×
21	canonicalId = did.asCanonical.toString,	×
22	versionId = HexString.fromByteArray(didMetadata.lastOperationHash.toArray).toString
23	)
24	}
25
26	extension (didData: DIDData) {	1✔
27	def toW3C(did: PrismDID): DIDDocumentRepr = {
28	import VerificationRelationship.*	1✔
29	val embeddedKeys = didData.publicKeys.map(k => k.toW3C(did, did))	1✔
30	val keyRefWithPurpose = didData.publicKeys.map(k => k.purpose -> s"${did.toString}#${k.id}")	1✔
31	val services = didData.services.map(_.toW3C(did))
32	DIDDocumentRepr(	1✔
33	id = did.toString,	1✔
34	controller = did.toString,
35	verificationMethod = embeddedKeys,	1✔
36	authentication = keyRefWithPurpose.collect { case (Authentication, k) => k },	1✔
37	assertionMethod = keyRefWithPurpose.collect { case (AssertionMethod, k) => k },	1✔
38	keyAgreement = keyRefWithPurpose.collect { case (KeyAgreement, k) => k },	1✔
39	capabilityInvocation = keyRefWithPurpose.collect { case (CapabilityInvocation, k) => k },	1✔
40	capabilityDelegation = keyRefWithPurpose.collect { case (CapabilityDelegation, k) => k },
41	service = services,	1✔
42	context = deriveContext(embeddedKeys, services)
43	)
44	}
45
46	// Reference: https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#constructing-a-json-ld-did-document	1✔
47	private def deriveContext(keys: Seq[PublicKeyRepr], services: Seq[ServiceRepr]): Seq[String] = {	×
48	val mandatoryContext = Seq("https://www.w3.org/ns/did/v1")
49	val additionalContext = {	1✔
50	val keyTypes = keys.map(_.`type`).toSet	1✔
51	val serviceTypes = services.map(_.`type`).toSet	×
52	Seq(	×
53	Option.when(keyTypes.contains("JsonWebKey2020"))("https://w3id.org/security/suites/jws-2020/v1"),	×
54	Option.when(serviceTypes.contains("DIDCommMessaging"))("https://didcomm.org/messaging/contexts/v2"),	×
55	Option.when(serviceTypes.contains("LinkedDomains"))(
56	"https://identity.foundation/.well-known/did-configuration/v1"
57	)
58	).flatten
59	}
60	val userDefinedContext = didData.context	×
61	mandatoryContext ++ additionalContext ++ userDefinedContext
62	}
63	}
64
65	extension (service: Service) {	1✔
66	def toW3C(did: PrismDID): ServiceRepr = ServiceRepr(	1✔
67	id = s"${did.toString}#${service.id}",
68	`type` = service.`type`.name,	1✔
69	serviceEndpoint = service.serviceEndpoint.map(_.toString)
70	)
71	}
72
73	extension (publicKey: PublicKey) {	1✔
74	def toW3C(did: PrismDID, controller: PrismDID): PublicKeyRepr = PublicKeyRepr(	1✔
75	id = s"${did.toString}#${publicKey.id}",
76	`type` = "EcdsaSecp256k1VerificationKey2019",	1✔
77	controller = controller.toString,
78	publicKeyJwk = publicKey.publicKeyData match {	1✔
79	case PublicKeyData.ECKeyData(crv, x, y) =>
80	PublicKeyJwk(
81	kty = "EC",
82	crv = crv.name,	1✔
83	x = x.toStringNoPadding,	1✔
84	y = y.toStringNoPadding
85	)	×
86	case pk: PublicKeyData.ECCompressedKeyData =>	×
87	val uncompressed = pk.toUncompressedKeyData
88	PublicKeyJwk(
89	kty = "EC",
90	crv = uncompressed.crv.name,	×
91	x = uncompressed.x.toStringNoPadding,	×
92	y = uncompressed.y.toStringNoPadding
93	)
94	}
95	)
96	}
97
98	}

input-output-hk / atala-prism-building-blocks / 5286569716

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous