@cheqd/sdk 1.5.0-develop.3 → 2.0.0-develop.1

package/src/types.ts

@@ -1,8 +1,8 @@
+import { Service as ProtobufService, VerificationMethod as ProtobufVerificationMethod } from "@cheqd/ts-proto/cheqd/did/v2"
 import { CheqdSDK } from "."
 import { Coin } from "@cosmjs/proto-signing"
 import { Signer } from "did-jwt"
-import { MsgCreateDidDocPayload, MsgDeactivateDidDocPayload, MsgUpdateDidDocPayload, VerificationMethod, Service } from "@cheqd/ts-proto/cheqd/did/v2"
-import { DeepPartial, Exact } from "cosmjs-types/confio/proofs"
+export { DIDDocument, VerificationMethod, Service, ServiceEndpoint, JsonWebKey } from "did-resolver"
 
 export enum CheqdNetwork {
     Mainnet = 'mainnet',
@@ -19,6 +19,13 @@ export interface IContext {
     sdk: CheqdSDK
 }
 
+export type SpecValidationResult = {
+    valid: boolean
+    error?: string
+    protobufVerificationMethod?: ProtobufVerificationMethod[]
+    protobufService?: ProtobufService[]
+}
+
 export enum VerificationMethods {
     Ed255192020 = 'Ed25519VerificationKey2020',
     Ed255192018 = 'Ed25519VerificationKey2018',
@@ -40,12 +47,6 @@ export interface ISignInputs {
     privateKeyHex: string
 }
 
-export const ISignInputs = {
-  isSignInput(object: Object[]): object is ISignInputs[] {
-		return object.some((x)=> 'privateKeyHex' in x)
-	}
-}
-
 export interface IKeyPair {
     publicKey: string
     privateKey: string
@@ -77,151 +78,8 @@ export interface DidStdFee {
     granter?: string
 }
 
-export interface MsgDeactivateDidPayload extends MsgDeactivateDidDocPayload {
-    verificationMethod: VerificationMethodPayload[]
-}
-
-export interface MsgCreateDidPayload extends Omit<MsgCreateDidDocPayload, 'verificationMethod' | 'service'> {
-    verificationMethod: VerificationMethodPayload[]
-    service: ServicePayload[]
-}
-
-export const MsgCreateDidPayload = {
-    transformPayload<I extends Exact<DeepPartial<MsgCreateDidPayload>, I>>(message: I): MsgCreateDidDocPayload {
-        const obj: any = {};
-        if (message.context) {
-          obj.context = message.context
-        } else {
-          obj.context = [];
-        }
-        message.id !== undefined && (obj.id = message.id);
-        if (message.controller) {
-          obj.controller = message.controller
-        }
-        if (message.verificationMethod) {
-          obj.verificationMethod = message.verificationMethod.map((e) => e ? VerificationMethodPayload.transformPayload(e) : undefined);
-        }
-        if (message.authentication) {
-          obj.authentication = message.authentication
-        }
-        if (message.assertionMethod) {
-          obj.assertionMethod = message.assertionMethod
-        }
-        if (message.capabilityInvocation) {
-          obj.capabilityInvocation = message.capabilityInvocation
-        }
-        if (message.capabilityDelegation) {
-          obj.capabilityDelegation = message.capabilityDelegation
-        }
-        if (message.keyAgreement) {
-          obj.keyAgreement = message.keyAgreement
-        }
-        if (message.alsoKnownAs) {
-          obj.alsoKnownAs = message.alsoKnownAs
-        }
-        if (message.service) {
-          obj.service = message.service.map((e) => e ? {id: e.id, serviceEndpoint: e.serviceEndpoint, serviceType: e.type} as Service : undefined);
-        }
-        message.versionId !== undefined && (obj.versionId = message.versionId);
-        return MsgCreateDidDocPayload.fromPartial(obj);
-      },
-
-    fromPartial<I extends Exact<DeepPartial<MsgCreateDidPayload>, I>>(object: I): MsgCreateDidPayload {
-        const message = createBaseMsgCreateDidPayload();
-        message.context = object.context?.map((e) => e) || [];
-        message.id = object.id ?? "";
-        message.controller = object.controller?.map((e) => e) || [];
-        message.verificationMethod = object.verificationMethod?.map((e) => VerificationMethodPayload.fromPartial(e)) || [];
-        message.authentication = object.authentication?.map((e) => e) || [];
-        message.assertionMethod = object.assertionMethod?.map((e) => e) || [];
-        message.capabilityInvocation = object.capabilityInvocation?.map((e) => e) || [];
-        message.capabilityDelegation = object.capabilityDelegation?.map((e) => e) || [];
-        message.keyAgreement = object.keyAgreement?.map((e) => e) || [];
-        message.alsoKnownAs = object.alsoKnownAs?.map((e) => e) || [];
-        message.service = object.service?.map((e) => ServicePayload.fromPartial(e)) || [];
-        message.versionId = object.versionId ?? "";
-        return message;
-    },
-    
-}
-
-function createBaseMsgCreateDidPayload(): MsgCreateDidPayload {
-    return {
-      context: [],
-      id: "",
-      controller: [],
-      verificationMethod: [],
-      authentication: [],
-      assertionMethod: [],
-      capabilityInvocation: [],
-      capabilityDelegation: [],
-      keyAgreement: [],
-      alsoKnownAs: [],
-      service: [],
-      versionId: "",
-    };
-  }
-
-export interface VerificationMethodPayload {
-    id: string;
-    type: string;
-    controller: string;
-    publicKeyBase58?: string;
-    publicKeyMultibase?: string;
-    publicKeyJWK?: any;
-}
-
-export const VerificationMethodPayload = {
-    fromPartial<I extends Exact<DeepPartial<VerificationMethodPayload>, I>>(object: I): VerificationMethodPayload {
-        const message = createBaseVerificationMethod();
-        message.id = object.id ?? "";
-        message.type = object.type ?? "";
-        message.controller = object.controller ?? "";
-        if(object.publicKeyMultibase) {
-          message.publicKeyMultibase = object.publicKeyMultibase;
-        } else if (object.publicKeyBase58) {
-          message.publicKeyBase58 = object.publicKeyBase58;
-        } else if (object.publicKeyJWK) {
-          message.publicKeyJWK = object.publicKeyJWK;
-        }
-        return message;
-      },
-    
-    transformPayload<I extends Exact<DeepPartial<VerificationMethodPayload>, I>>(payload: I): VerificationMethod {
-      return {
-        id: payload.id ?? "", 
-        controller: payload.controller ?? "", 
-        verificationMethodType: payload.type ?? "", 
-        verificationMaterial: payload.publicKeyBase58 || payload.publicKeyMultibase || JSON.stringify(payload.publicKeyJWK) || ""
-      } as VerificationMethod
-    }
-}
-
-function createBaseVerificationMethod(): VerificationMethodPayload {
-    return { id: "", type: "", controller: ""  };
-}
-
-export interface ServicePayload {
-    id: string;
-    type: string;
-    serviceEndpoint: string[];
-}
-
-export const ServicePayload = {
-    fromPartial<I extends Exact<DeepPartial<ServicePayload>, I>>(object: I): ServicePayload {
-        const message = createBaseService();
-        message.id = object.id ?? "";
-        message.type = object.type ?? "";
-        message.serviceEndpoint = object.serviceEndpoint?.map((e) => e) || [];
-        return message;
-      },
-}
-
-function createBaseService(): ServicePayload {
-    return { id: "", type: "", serviceEndpoint: [] };
-}
-
-export interface MsgUpdateDidPayload extends Omit<MsgUpdateDidDocPayload, 'verificationMethod' | 'service'> {
-    verificationMethod: VerificationMethodPayload[]
-    service: ServicePayload[]
-}
+export const ISignInputs = {
+  isSignInput(object: Object[]): object is ISignInputs[] {
+		return object.some((x)=> 'privateKeyHex' in x)
+	}
+}

package/src/utils.ts

@@ -8,10 +8,11 @@ import {
     TVerificationKey, 
     TVerificationKeyPrefix, 
     CheqdNetwork, 
-    IVerificationKeys, 
-    MsgCreateDidPayload,
-    VerificationMethodPayload,
-    MsgUpdateDidPayload
+    IVerificationKeys,
+    VerificationMethod,
+    DIDDocument,
+    SpecValidationResult,
+    JsonWebKey,
 } from "./types"
 import { fromString, toString } from 'uint8arrays'
 import { bases } from "multiformats/basics"
@@ -19,6 +20,10 @@ import { base64ToBytes } from "did-jwt"
 import { generateKeyPair, generateKeyPairFromSeed, KeyPair } from '@stablelib/ed25519'
 import { v4 } from 'uuid'
 import { createHash } from 'crypto'
+import {
+    VerificationMethod as ProtoVerificationMethod,
+    Service as ProtoService,
+} from "@cheqd/ts-proto/cheqd/did/v2"
 
 export type TImportableEd25519Key = {
     publicKeyHex: string
@@ -27,16 +32,13 @@ export type TImportableEd25519Key = {
     type: "Ed25519"
 }
 
-// multicodec ed25519-pub header as varint
-const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
-
-export type IdentifierPayload = Partial<MsgCreateDidPayload> | Partial<MsgUpdateDidPayload>
+const MULTICODEC_ED25519_HEADER = new Uint8Array([0xed, 0x01]);
 
 export function isEqualKeyValuePair(kv1: IKeyValuePair[], kv2: IKeyValuePair[]): boolean {
     return kv1.every((item, index) => item.key === kv2[index].key && item.value === kv2[index].value)
 }
 
-export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519Key, verificationMethod: VerificationMethodPayload[]): ISignInputs {
+export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519Key, verificationMethod: VerificationMethod[]): ISignInputs {
     if (verificationMethod?.length === 0) throw new Error('No verification methods provided')
 
     const publicKey = fromString(key.publicKeyHex, 'hex')
@@ -44,14 +46,13 @@ export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519
     for(const method of verificationMethod) {
         switch (method?.type) {
             case VerificationMethods.Ed255192020:
-                const publicKeyMultibase = _encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, publicKey)
+                const publicKeyMultibase = toMultibaseRaw(publicKey)
                 if (method.publicKeyMultibase === publicKeyMultibase) {
                     return {
                         verificationMethodId: method.id,
                         privateKeyHex: key.privateKeyHex
                     }
                 }
-            
             case VerificationMethods.Ed255192018:
                 const publicKeyBase58 = bases['base58btc'].encode(publicKey).slice(1)
                 if (method.publicKeyBase58 === publicKeyBase58) {
@@ -60,20 +61,17 @@ export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519
                         privateKeyHex: key.privateKeyHex
                     }
                 }
-
             case VerificationMethods.JWK:
-                const publicKeyJWK: any = {
+                const publicKeyJwk: JsonWebKey = {
                     crv: 'Ed25519',
                     kty: 'OKP',
                     x: toString( publicKey, 'base64url' )
                 }
-                if (JSON.stringify(method.publicKeyJWK) === JSON.stringify(publicKeyJWK)) {
+                if (JSON.stringify(method.publicKeyJwk) === JSON.stringify(publicKeyJwk)) {
                     return {
                         verificationMethodId: method.id,
                         privateKeyHex: key.privateKeyHex
                     }
-                } else {
-                    throw new Error(`JWK not matching ${method.publicKeyJWK}, ${publicKeyJWK}`)
                 }
         }
     }
@@ -128,7 +126,7 @@ export function createVerificationKeys(publicKey: string, algo: MethodSpecificId
     }
 }
 
-export function createDidVerificationMethod(verificationMethodTypes: VerificationMethods[], verificationKeys: IVerificationKeys[]): VerificationMethodPayload[] {
+export function createDidVerificationMethod(verificationMethodTypes: VerificationMethods[], verificationKeys: IVerificationKeys[]): VerificationMethod[] {
     return verificationMethodTypes.map((type, _) => {
         switch (type) {
             case VerificationMethods.Ed255192020:
@@ -136,61 +134,110 @@ export function createDidVerificationMethod(verificationMethodTypes: Verificatio
                     id: verificationKeys[_].keyId,
                     type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyMultibase: _encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, base64ToBytes(verificationKeys[_].publicKey))
-                }
-            
+                    publicKeyMultibase: toMultibaseRaw(base64ToBytes(verificationKeys[_].publicKey))
+                } as VerificationMethod
             case VerificationMethods.Ed255192018:
                 return {
                     id: verificationKeys[_].keyId,
                     type,
                     controller: verificationKeys[_].didUrl,
                     publicKeyBase58: verificationKeys[_].methodSpecificId.slice(1)
-                }
-
+                } as VerificationMethod
             case VerificationMethods.JWK:
                 return {
                     id: verificationKeys[_].keyId,
                     type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyJWK: {
+                    publicKeyJwk: {
                         crv: 'Ed25519',
                         kty: 'OKP',
                         x: toString( fromString( verificationKeys[_].publicKey, 'base64pad' ), 'base64url' )
                     }
-                }
+                } as VerificationMethod
         }
     }) ?? []
 }
 
-export function createDidPayload(verificationMethods: VerificationMethodPayload[], verificationKeys: IVerificationKeys[]): MsgCreateDidPayload {
+export function createDidPayload(verificationMethods: VerificationMethod[], verificationKeys: IVerificationKeys[]): DIDDocument {
     if (!verificationMethods || verificationMethods.length === 0)
         throw new Error('No verification methods provided')
     if (!verificationKeys || verificationKeys.length === 0)
         throw new Error('No verification keys provided')
 
     const did = verificationKeys[0].didUrl
-    return MsgCreateDidPayload.fromPartial(
-        {
+    return {
             id: did,
             controller: verificationKeys.map(key => key.didUrl),
             verificationMethod: verificationMethods,
             authentication: verificationKeys.map(key => key.keyId),
-            versionId: v4()
+    } as DIDDocument
+}
+
+export function validateSpecCompliantPayload(didDocument: DIDDocument): SpecValidationResult {
+    // id is required, validated on both compile and runtime
+    if (!didDocument?.id) return { valid: false, error: 'id is required' }
+
+    // verificationMethod is required
+    if (!didDocument?.verificationMethod) return { valid: false, error: 'verificationMethod is required' }
+
+    // verificationMethod must be an array
+    if (!Array.isArray(didDocument?.verificationMethod)) return { valid: false, error: 'verificationMethod must be an array' }
+
+    // verificationMethod types must be supported
+    const protoVerificationMethod = didDocument.verificationMethod.map((vm) => {
+        switch (vm?.type) {
+            case VerificationMethods.Ed255192020:
+                if (!vm.publicKeyMultibase) throw new Error('publicKeyMultibase is required')
+
+                return ProtoVerificationMethod.fromPartial({
+                    id: vm.id,
+                    controller: vm.controller,
+                    verificationMethodType: VerificationMethods.Ed255192020,
+                    verificationMaterial: vm.publicKeyMultibase,
+                })
+            case VerificationMethods.JWK:
+                if (!vm.publicKeyJwk) throw new Error('publicKeyJwk is required')
+
+                return ProtoVerificationMethod.fromPartial({
+                    id: vm.id,
+                    controller: vm.controller,
+                    verificationMethodType: VerificationMethods.JWK,
+                    verificationMaterial: JSON.stringify(vm.publicKeyJwk),
+                })
+            case VerificationMethods.Ed255192018:
+                if (!vm.publicKeyBase58) throw new Error('publicKeyBase58 is required')
+
+                return ProtoVerificationMethod.fromPartial({
+                    id: vm.id,
+                    controller: vm.controller,
+                    verificationMethodType: VerificationMethods.Ed255192018,
+                    verificationMaterial: vm.publicKeyBase58,
+                })
+            default:
+                throw new Error(`Unsupported verificationMethod type: ${vm?.type}`)
         }
-    )
+    })
+
+    const protoService = didDocument?.service?.map((s) => {
+        return ProtoService.fromPartial({
+            id: s?.id,
+            serviceType: s?.type,
+            serviceEndpoint: <string[]>s?.serviceEndpoint,
+        })
+    })
+
+    return { valid: true, protobufVerificationMethod: protoVerificationMethod, protobufService: protoService }
 }
 
 function sha256(message: string) {
     return createHash('sha256').update(message).digest('hex')
 }
 
-// encode a multibase base58-btc multicodec key
-function _encodeMbKey(header: any, key: Uint8Array) {
-    const mbKey = new Uint8Array(header.length + key.length);
-  
-    mbKey.set(header);
-    mbKey.set(key, header.length);
-  
-    return bases['base58btc'].encode(mbKey);
+function toMultibaseRaw(key: Uint8Array) {
+    const multibase = new Uint8Array(MULTICODEC_ED25519_HEADER.length + key.length);
+
+    multibase.set(MULTICODEC_ED25519_HEADER);
+    multibase.set(key, MULTICODEC_ED25519_HEADER.length);
+
+    return bases['base58btc'].encode(multibase);
 }
-  

package/tests/index.test.ts

@@ -1,6 +1,6 @@
 import { DirectSecp256k1HdWallet, GeneratedType } from '@cosmjs/proto-signing'
 import { createCheqdSDK, DIDModule, ICheqdSDKOptions, ResourceModule } from '../src/index'
-import { exampleCheqdNetwork, faucet } from './testutils.test'
+import { localnet, faucet } from './testutils.test'
 import { AbstractCheqdSDKModule } from '../src/modules/_'
 import { CheqdSigningStargateClient } from '../src/signer'
 import { createDefaultCheqdRegistry } from '../src/registry'
@@ -11,7 +11,7 @@ describe(
             it('can be instantiated with modules', async () => {
                 const options = {
                     modules: [DIDModule as unknown as AbstractCheqdSDKModule],
-                    rpcUrl: exampleCheqdNetwork.rpcUrl,
+                    rpcUrl: localnet.rpcUrl,
                     wallet: await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
                 } as ICheqdSDKOptions
                 const cheqdSDK = await createCheqdSDK(options)
@@ -26,7 +26,7 @@ describe(
             })
 
             it('should use module methods', async () => {
-                const rpcUrl = exampleCheqdNetwork.rpcUrl
+                const rpcUrl = localnet.rpcUrl
                 const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
 
                 class TestModule extends AbstractCheqdSDKModule {
@@ -56,7 +56,6 @@ describe(
                 const doSomething = await cheqdSDK.doSomething()
                 expect(doSomething).toBe('did something')
 
-                //@ts-ignore
                 const spy = jest.spyOn(cheqdSDK.methods, 'doSomething')
                 //@ts-ignore
                 await cheqdSDK.doSomething()
@@ -66,7 +65,7 @@ describe(
             it('should instantiate registry from passed modules', async () => {
                 const options = {
                     modules: [DIDModule as unknown as AbstractCheqdSDKModule],
-                    rpcUrl: exampleCheqdNetwork.rpcUrl,
+                    rpcUrl: localnet.rpcUrl,
                     wallet: await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
                 } as ICheqdSDKOptions
                 const cheqdSDK = await createCheqdSDK(options)
@@ -80,7 +79,7 @@ describe(
             it('should instantiate registry from multiple passed modules', async () => {
                 const options = {
                     modules: [DIDModule as unknown as AbstractCheqdSDKModule, ResourceModule as unknown as AbstractCheqdSDKModule],
-                    rpcUrl: exampleCheqdNetwork.rpcUrl,
+                    rpcUrl: localnet.rpcUrl,
                     wallet: await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
                 } as ICheqdSDKOptions
                 const cheqdSDK = await createCheqdSDK(options)