feat: Improve /did/create API [DEV-3197]

package.json

@@ -49,7 +49,7 @@
 	],
 	"dependencies": {
 		"@cheqd/did-provider-cheqd": "^3.6.8",
-		"@cheqd/sdk": "^3.7.0",
+		"@cheqd/sdk": "^3.7.1",
 		"@cheqd/ts-proto": "^3.3.1",
 		"@cosmjs/amino": "^0.31.1",
 		"@cosmjs/encoding": "^0.31.1",

src/controllers/issuer.ts

@@ -3,12 +3,11 @@ import { check, param, validationResult } from 'express-validator';
 import { fromString } from 'uint8arrays';
 import type { DIDDocument, Service, VerificationMethod } from 'did-resolver';
 import { v4 } from 'uuid';
-import { MethodSpecificIdAlgo, VerificationMethods, CheqdNetwork } from '@cheqd/sdk';
+import { CheqdNetwork, MethodSpecificIdAlgo, VerificationMethods } from '@cheqd/sdk';
 import type { MsgCreateResourcePayload } from '@cheqd/ts-proto/cheqd/resource/v2/index.js';
 import { StatusCodes } from 'http-status-codes';
-
 import { IdentityServiceStrategySetup } from '../services/identity/index.js';
-import { generateDidDoc, getQueryParams, validateSpecCompliantPayload } from '../helpers/helpers.js';
+import { generateDidDoc, generateVerificationMethod, getQueryParams, validateDidCreatePayload, validateSpecCompliantPayload } from '../helpers/helpers.js';
 import { DIDMetadataDereferencingResult, DefaultResolverUrl } from '@cheqd/did-provider-cheqd';
 
 export class IssuerController {
@@ -17,7 +16,7 @@ export class IssuerController {
 			.optional()
 			.isObject()
 			.custom((value) => {
-				const { valid } = validateSpecCompliantPayload(value);
+				const { valid } = validateDidCreatePayload(value);
 				return valid;
 			})
 			.withMessage('Invalid didDocument'),
@@ -26,11 +25,11 @@ export class IssuerController {
 			.isString()
 			.isIn([VerificationMethods.Ed255192020, VerificationMethods.Ed255192018, VerificationMethods.JWK])
 			.withMessage('Invalid verificationMethod'),
-		check('methodSpecificIdAlgo')
+		check('identifierFormatType')
 			.optional()
 			.isString()
 			.isIn([MethodSpecificIdAlgo.Base58, MethodSpecificIdAlgo.Uuid])
-			.withMessage('Invalid methodSpecificIdAlgo'),
+			.withMessage('Invalid identifierFormatType'),
 		check('network')
 			.optional()
 			.isString()
@@ -187,7 +186,7 @@ export class IssuerController {
 	 *       content:
 	 *         application/x-www-form-urlencoded:
 	 *           schema:
-	 *             $ref: '#/components/schemas/DidCreateRequest'
+	 *             $ref: '#/components/schemas/DidCreateRequestFormBased'
 	 *         application/json:
 	 *           schema:
 	 *             $ref: '#/components/schemas/DidCreateRequest'
@@ -226,39 +225,54 @@ export class IssuerController {
 		}
 
 		const {
-			methodSpecificIdAlgo,
+			identifierFormatType,
 			network,
 			verificationMethodType,
-			assertionMethod = true,
-			serviceEndpoint,
+			service,
+			key,
+			options,
 		} = request.body;
 		let didDocument: DIDDocument;
 		try {
 			if (request.body.didDocument) {
 				didDocument = request.body.didDocument;
+				if (options) {
+					const publicKeyHex = options.key || (await new IdentityServiceStrategySetup(response.locals.customerId).agent.createKey(
+						'Ed25519',
+						response.locals.customerId
+					)).publicKeyHex;
+
+					didDocument.verificationMethod = [
+						generateVerificationMethod(didDocument.id, publicKeyHex, options.verificationMethodType)
+					];
+				} else {
+					return response.status(StatusCodes.BAD_REQUEST).json({
+						error: 'Provide options section to create a DID',
+					});
+				}
 			} else if (verificationMethodType) {
-				const key = await new IdentityServiceStrategySetup(response.locals.customerId).agent.createKey(
+				const publicKeyHex = key || (await new IdentityServiceStrategySetup(response.locals.customerId).agent.createKey(
 					'Ed25519',
 					response.locals.customerId
-				);
+				)).publicKeyHex;
 				didDocument = generateDidDoc({
-					verificationMethod: verificationMethodType || VerificationMethods.Ed255192018,
+					verificationMethod: verificationMethodType,
 					verificationMethodId: 'key-1',
-					methodSpecificIdAlgo: (methodSpecificIdAlgo as MethodSpecificIdAlgo) || MethodSpecificIdAlgo.Uuid,
+					methodSpecificIdAlgo: (identifierFormatType as MethodSpecificIdAlgo) || MethodSpecificIdAlgo.Uuid,
 					network,
-					publicKey: key.publicKeyHex,
+					publicKey: publicKeyHex,
 				});
 
-				if (assertionMethod) {
-					didDocument.assertionMethod = didDocument.authentication;
+				if (typeof request.body['@context'] === 'string') {
+					didDocument['@context'] = [request.body['@context']] ;
 				}
 
-				if (serviceEndpoint) {
+				if (service) {
 					didDocument.service = [
 						{
-							id: `${didDocument.id}#service-1`,
-							type: 'service-1',
-							serviceEndpoint: [serviceEndpoint],
+							id: `${didDocument.id}#${service.idFragment}`,
+							type: service.type,
+							serviceEndpoint: service.serviceEndpoint,
 						},
 					];
 				}
@@ -507,7 +521,7 @@ export class IssuerController {
 			if (result) {
 				const url = new URL(
 					`${process.env.RESOLVER_URL || DefaultResolverUrl}${did}?` +
-						`resourceId=${resourcePayload.id}&resourceMetadata=true`
+					`resourceId=${resourcePayload.id}&resourceMetadata=true`
 				);
 				const didDereferencing = (await (await fetch(url)).json()) as DIDMetadataDereferencingResult;
 
@@ -651,11 +665,11 @@ export class IssuerController {
 		try {
 			const did = request.params.did
 				? await new IdentityServiceStrategySetup(response.locals.customerId).agent.resolveDid(
-						request.params.did
-				  )
+					request.params.did
+				)
 				: await new IdentityServiceStrategySetup(response.locals.customerId).agent.listDids(
-						response.locals.customerId
-				  );
+					response.locals.customerId
+				);
 
 			return response.status(StatusCodes.OK).json(did);
 		} catch (error) {

src/helpers/helpers.ts

@@ -1,4 +1,4 @@
-import type { DIDDocument } from 'did-resolver';
+import type { DIDDocument, VerificationMethod } from 'did-resolver';
 import {
 	MethodSpecificIdAlgo,
 	CheqdNetwork,
@@ -8,13 +8,17 @@ import {
 	createVerificationKeys,
 	createDidVerificationMethod,
 	createDidPayload,
+	toMultibaseRaw,
 } from '@cheqd/sdk';
 import { createHmac } from 'node:crypto';
 import type { ParsedQs } from 'qs';
 import type { SpecValidationResult } from '../types/shared.js';
 import { DEFAULT_DENOM_EXPONENT, MINIMAL_DENOM } from '../types/constants.js';
 import { LitCompatibleCosmosChains, type DkgOptions, LitNetworks } from '@cheqd/did-provider-cheqd';
 import type { Coin } from '@cosmjs/amino';
+import { fromString, toString } from 'uint8arrays';
+import { bases } from "multiformats/basics";
+import { base64ToBytes } from "did-jwt";
 
 export interface IDidDocOptions {
 	verificationMethod: VerificationMethods;
@@ -66,6 +70,14 @@ export function toDefaultDkg(did: string): DkgOptions {
 	}
 }
 
+export function validateDidCreatePayload(didDocument: DIDDocument): SpecValidationResult {
+	// id is required, validated on both compile and runtime
+	if (!didDocument.id && !didDocument.id.startsWith('did:cheqd:')) return { valid: false, error: 'id is required' };
+
+	if (!isValidService(didDocument)) return { valid: false, error: 'Service is Invalid' };
+	return { valid: true } as SpecValidationResult;
+}
+
 export function validateSpecCompliantPayload(didDocument: DIDDocument): SpecValidationResult {
 	// id is required, validated on both compile and runtime
 	if (!didDocument.id && !didDocument.id.startsWith('did:cheqd:')) return { valid: false, error: 'id is required' };
@@ -92,8 +104,8 @@ export function validateSpecCompliantPayload(didDocument: DIDDocument): SpecVali
 export function isValidService(didDocument: DIDDocument): boolean {
 	return didDocument.service
 		? didDocument?.service?.every((s) => {
-				return s?.serviceEndpoint && s?.id && s?.type;
-		  })
+			return s?.serviceEndpoint && s?.id && s?.type;
+		})
 		: true;
 }
 
@@ -124,6 +136,53 @@ export function generateDidDoc(options: IDidDocOptions) {
 	return createDidPayload(verificationMethods, [verificationKeys]);
 }
 
+export function generateVerificationMethod(
+	did: string, 
+	publicKeyHex: string,
+	verificationMethodType: VerificationMethods
+): VerificationMethod {
+	const pkBase64 = publicKeyHex.length == 43 ? publicKeyHex : toString(fromString(publicKeyHex, 'hex'), 'base64');
+	switch (verificationMethodType) {
+		case VerificationMethods.Ed255192018:
+			return generateVerificationMethodEd255192018(did, pkBase64);
+		case VerificationMethods.Ed255192020:
+			return generateVerificationMethodEd255192020(did, pkBase64);
+		case VerificationMethods.JWK:
+			return generateVerificationMethodJWK(did, pkBase64);
+	};
+}
+
+function generateVerificationMethodEd255192018(did: string, pkBase64: string) {
+	return {
+		id: `${did}#key-1`,
+		type: VerificationMethods.Ed255192018,
+		controller: did,
+		publicKeyBase58: bases['base58btc'].encode(base64ToBytes(pkBase64)).slice(1)
+	};
+}
+
+function generateVerificationMethodEd255192020(did: string, pkBase64: string) {
+	return {
+		id: `${did}#key-1`,
+		type: VerificationMethods.Ed255192020,
+		controller: did,
+		publicKeyMultibase: toMultibaseRaw(base64ToBytes(pkBase64))
+	};
+}
+
+function generateVerificationMethodJWK(did: string, pkBase64: string) {
+	return {
+		id: `${did}#key-1`,
+		type: VerificationMethods.JWK,
+		controller: did,
+		publicKeyJwk: {
+			crv: 'Ed25519',
+			kty: 'OKP',
+			x: toString(fromString(pkBase64, 'base64pad'), 'base64url')
+		}
+	};
+}
+
 export function verifyHookSignature(signingKey: string, rawBody: string, expectedSignature: string): boolean {
 	const hmac = createHmac('sha256', signingKey);
 	hmac.update(rawBody);