Edge Agent SDK [Multiplatform] & Universal prism:did resolver

[elribonazo]

Universal resolver (prism:did)

---

Context

As we all know JWT and SDJWT use the issuer DID to issue and verify SSI Credentials. Our SDK is currently bundling 2 did resolvers in Castor.

1. PeerDID resolver
2. PrismDID resolver (long form) is the long form presentation of the prism:did and contains the keys serialized inside, close to what the did:key provides.

Roadmap

Both JWT and SDJWT will very soon be issued with the short form prism:did which requires to be resolved on testnet, mainnet or using a custom resolver.

Option 1 (API resolver)

When the prism:did operations are being stored in a prism:node with inMemory storage, we won't be able to resolve on cardano directly so we will need a custom resolver using the Issuer's endpoint.

Note

This option is the less recommended option as it does not act in favor of a more decentralized and user centric approach, introduced a centralised endpoint (issuer API) to resolve the DID VS other methods that write transactions on chain.

Example:

import SDK from "@hyperledger/identus-edge-agent-sdk";

const CLOUD_AGENT_BASE_URL = "http://localhost:8000/cloud-agent/";

class ShortFormDIDResolverSample {
    method = "prism";

    async resolve(didString) {
        const url = CLOUD_AGENT_BASE_URL + "dids/" + didString;
        const response = await fetch(url, {
            method: "GET",
            mode: "cors",
            credentials: "omit"
        });

        if (!response.ok) {
            throw new Error('Failed to fetch data');
        }

        const data = await response.json();
        const didDocument = data.didDocument;

        const servicesProperty = new SDK.Domain.Services(didDocument.service);
        const verificationMethodsProperty = new SDK.Domain.VerificationMethods(didDocument.verificationMethod);
        const coreProperties = [];
        const authenticate = [];
        const assertion = [];

        for (const verificationMethod of didDocument.verificationMethod) {
            const isAssertion = didDocument.assertionMethod.find(method => method === verificationMethod.id);
            if (isAssertion) {
                assertion.push(new SDK.Domain.AssertionMethod([isAssertion], [verificationMethod]));
            }
            const isAuthentication = didDocument.authentication.find(method => method === verificationMethod.id);
            if (isAuthentication) {
                authenticate.push(new SDK.Domain.Authentication([isAuthentication], [verificationMethod]));
            }
        }

        coreProperties.push(...authenticate);
        coreProperties.push(servicesProperty);
        coreProperties.push(verificationMethodsProperty);

        const resolved = new SDK.Domain.DIDDocument(
            SDK.Domain.DID.fromString(didString),
            coreProperties
        );

        return resolved;
    }
}

Option 2 (Cardano resolver)

This option is the most recommended option and here's where we want to drive the discussion and debate into.

Most simple approach would be to create a prism:did resolver using the blockfrost API.

There's now several approaches to implement and add this functionality to our SDKs:

1. Add blockfrost API resolver by default in our SDK and enable opt-in (mainnet/testnet) through agent options

2. Better responsability separation, create external (community maintainet) prism:did resolver. Same as previous option but not bundled in our SDK. Main difference in here is that u would need to create the instance of the resolver and then passing it to Castor, VS the first option which would do the same by just passing a property to the Agent.

Option 3 (Document the process and leave up to devs)

This is the option that requires less amount of work, we will just document the process that devs need to follow to integrate a resolver and how to integrate it with the agent but the team won't maintain the package and the resolvers.