@cheqd/sdk 1.4.0-develop.5 → 1.5.0-develop.1

package/src/modules/did.ts

@@ -1,65 +1,97 @@
 import { createProtobufRpcClient, DeliverTxResponse, QueryClient } from "@cosmjs/stargate"
-/* import { QueryClientImpl } from '@cheqd/ts-proto/cheqd/v1/query' */
+/* import { QueryClientImpl } from '@cheqd/ts-proto/cheqd/did/v1/query' */
 import { CheqdExtension, AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
 import { CheqdSigningStargateClient } from "../signer"
-import { DidStdFee, IContext, ISignInputs } from "../types"
-import { MsgCreateDid, MsgCreateDidPayload, MsgCreateDidResponse, MsgUpdateDid, MsgUpdateDidPayload, MsgUpdateDidResponse, protobufPackage } from "@cheqd/ts-proto/cheqd/v1/tx"
+import { DidStdFee, IContext, ISignInputs, MsgDeactivateDidPayload } from "../types"
+import { 
+	MsgCreateDidDoc, 
+	MsgCreateDidDocPayload, 
+	MsgCreateDidDocResponse, 
+	MsgDeactivateDidDoc, 
+	MsgDeactivateDidDocPayload, 
+	MsgDeactivateDidDocResponse, 
+	MsgUpdateDidDoc, 
+	MsgUpdateDidDocPayload, 
+	MsgUpdateDidDocResponse, 
+	protobufPackage 
+} from "@cheqd/ts-proto/cheqd/did/v2"
 import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing"
 
-export const typeUrlMsgCreateDid = `/${protobufPackage}.MsgCreateDid`
-export const typeUrlMsgCreateDidResponse = `/${protobufPackage}.MsgCreateDidResponse`
-export const typeUrlMsgUpdateDid = `/${protobufPackage}.MsgUpdateDid`
-export const typeUrlMsgUpdateDidResponse = `/${protobufPackage}.MsgUpdateDidResponse`
+export const typeUrlMsgCreateDidDoc = `/${protobufPackage}.MsgCreateDidDoc`
+export const typeUrlMsgCreateDidDocResponse = `/${protobufPackage}.MsgCreateDidDocResponse`
+export const typeUrlMsgUpdateDidDoc = `/${protobufPackage}.MsgUpdateDidDoc`
+export const typeUrlMsgUpdateDidDocResponse = `/${protobufPackage}.MsgUpdateDidDocResponse`
+export const typeUrlMsgDeactivateDidDoc = `/${protobufPackage}.MsgDeactivateDidDoc`
+export const typeUrlMsgDeactivateDidDocResponse = `/${protobufPackage}.MsgDeactivateDidDocResponse`
 
-export interface MsgCreateDidEncodeObject extends EncodeObject {
-	readonly typeUrl: typeof typeUrlMsgCreateDid,
-	readonly value: Partial<MsgCreateDid>
+export interface MsgCreateDidDocEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgCreateDidDoc,
+	readonly value: Partial<MsgCreateDidDoc>
 }
 
-export function isMsgCreateDidEncodeObject(obj: EncodeObject): obj is MsgCreateDidEncodeObject {
-	return obj.typeUrl === typeUrlMsgCreateDid
+export function isMsgCreateDidDocEncodeObject(obj: EncodeObject): obj is MsgCreateDidDocEncodeObject {
+	return obj.typeUrl === typeUrlMsgCreateDidDoc
 }
 
-export interface MsgCreateDidResponseEncodeObject extends EncodeObject {
-	readonly typeUrl: typeof typeUrlMsgCreateDidResponse,
-	readonly value: Partial<MsgCreateDidResponse>
+export interface MsgCreateDidDocResponseEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgCreateDidDocResponse,
+	readonly value: Partial<MsgCreateDidDocResponse>
 }
 
-export function MsgCreateDidResponseEncodeObject(obj: EncodeObject): obj is MsgCreateDidResponseEncodeObject {
-	return obj.typeUrl === typeUrlMsgCreateDidResponse
+export function MsgCreateDidDocResponseEncodeObject(obj: EncodeObject): obj is MsgCreateDidDocResponseEncodeObject {
+	return obj.typeUrl === typeUrlMsgCreateDidDocResponse
 }
 
-export interface MsgUpdateDidEncodeObject extends EncodeObject {
-	readonly typeUrl: typeof typeUrlMsgUpdateDid,
-	readonly value: Partial<MsgUpdateDid>
+export interface MsgUpdateDidDocEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgUpdateDidDoc,
+	readonly value: Partial<MsgUpdateDidDoc>
 }
 
-export function MsgUpdateDidEncodeObject(obj: EncodeObject): obj is MsgUpdateDidEncodeObject {
-	return obj.typeUrl === typeUrlMsgUpdateDid
+export function MsgUpdateDidDocEncodeObject(obj: EncodeObject): obj is MsgUpdateDidDocEncodeObject {
+	return obj.typeUrl === typeUrlMsgUpdateDidDoc
 }
 
-export interface MsgUpdateDidResponseEncodeObject extends EncodeObject {
-	readonly typeUrl: typeof typeUrlMsgUpdateDidResponse,
-	readonly value: Partial<MsgUpdateDidResponse>
+export interface MsgUpdateDidDocResponseEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgUpdateDidDocResponse,
+	readonly value: Partial<MsgUpdateDidDocResponse>
 }
 
-export function MsgUpdateDidResponseEncodeObject(obj: EncodeObject): obj is MsgUpdateDidResponseEncodeObject {
-	return obj.typeUrl === typeUrlMsgUpdateDidResponse
+export function MsgUpdateDidDocResponseEncodeObject(obj: EncodeObject): obj is MsgUpdateDidDocResponseEncodeObject {
+	return obj.typeUrl === typeUrlMsgUpdateDidDocResponse
+}
+
+export interface MsgDeactivateDidDocEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgDeactivateDidDoc,
+	readonly value: Partial<MsgDeactivateDidDoc>
+}
+
+export function MsgDeactivateDidDocEncodeObject(obj: EncodeObject): obj is MsgUpdateDidDocEncodeObject {
+	return obj.typeUrl === typeUrlMsgDeactivateDidDoc
+}
+
+export interface MsgDeactivateDidDocResponseEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgDeactivateDidDocResponse,
+	readonly value: Partial<MsgDeactivateDidDocResponse>
+}
+
+export function MsgDeactiveDidDocResponseEncodeObject(obj: EncodeObject): obj is MsgDeactivateDidDocResponseEncodeObject {
+	return obj.typeUrl === typeUrlMsgUpdateDidDocResponse
 }
 
 export class DIDModule extends AbstractCheqdSDKModule {
 	static readonly registryTypes: Iterable<[string, GeneratedType]> = [
-        [typeUrlMsgCreateDid, MsgCreateDid],
-        [typeUrlMsgCreateDidResponse, MsgCreateDidResponse],
-        [typeUrlMsgUpdateDid, MsgUpdateDid],
-        [typeUrlMsgUpdateDidResponse, MsgUpdateDidResponse],
+        [typeUrlMsgCreateDidDoc, MsgCreateDidDoc],
+        [typeUrlMsgCreateDidDocResponse, MsgCreateDidDocResponse],
+        [typeUrlMsgUpdateDidDoc, MsgUpdateDidDoc],
+        [typeUrlMsgUpdateDidDocResponse, MsgUpdateDidDocResponse],
     ]
 
 	constructor(signer: CheqdSigningStargateClient) {
 		super(signer)
 		this.methods = {
 			createDidTx: this.createDidTx.bind(this),
-			updateDidTx: this.updateDidTx.bind(this)
+			updateDidTx: this.updateDidTx.bind(this),
+			deactivateDidTx: this.deactivateDidTx.bind(this),
 		}
 	}
 
@@ -67,21 +99,21 @@ export class DIDModule extends AbstractCheqdSDKModule {
         return DIDModule.registryTypes
     }
 
-	async createDidTx(signInputs: ISignInputs[], didPayload: Partial<MsgCreateDidPayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async createDidTx(signInputs: ISignInputs[], didPayload: Partial<MsgCreateDidDocPayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}
 
-		const payload = MsgCreateDidPayload.fromPartial(didPayload)
+		const payload = MsgCreateDidDocPayload.fromPartial(didPayload)
 		const signatures = await this._signer.signCreateDidTx(signInputs, payload)
 
-		const value: MsgCreateDid = {
+		const value: MsgCreateDidDoc = {
 			payload,
 			signatures
 		}
 
-		const createDidMsg: MsgCreateDidEncodeObject = {
-			typeUrl: typeUrlMsgCreateDid,
+		const createDidMsg: MsgCreateDidDocEncodeObject = {
+			typeUrl: typeUrlMsgCreateDidDoc,
 			value
 		}
 
@@ -93,21 +125,21 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		)
 	}
 
-	async updateDidTx(signInputs: ISignInputs[], didPayload: Partial<MsgUpdateDidPayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async updateDidTx(signInputs: ISignInputs[], didPayload: Partial<MsgUpdateDidDocPayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}
 
-		const payload = MsgUpdateDidPayload.fromPartial(didPayload)
+		const payload = MsgUpdateDidDocPayload.fromPartial(didPayload)
 		const signatures = await this._signer.signUpdateDidTx(signInputs, payload)
 
-		const value: MsgUpdateDid = {
+		const value: MsgUpdateDidDoc = {
 			payload,
 			signatures
 		}
 
-		const updateDidMsg: MsgUpdateDidEncodeObject = {
-			typeUrl: typeUrlMsgUpdateDid,
+		const updateDidMsg: MsgUpdateDidDocEncodeObject = {
+			typeUrl: typeUrlMsgUpdateDidDoc,
 			value
 		}
 
@@ -118,6 +150,32 @@ export class DIDModule extends AbstractCheqdSDKModule {
 			memo
 		)
 	}
+
+	async deactivateDidTx(signInputs: ISignInputs[], didPayload: MsgDeactivateDidPayload, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
+		if (!this._signer) {
+			this._signer = context!.sdk!.signer
+		}
+
+		const payload = MsgDeactivateDidDocPayload.fromPartial({id: didPayload.id, versionId: didPayload.versionId})
+		const signatures = await this._signer.signDeactivateDidTx(signInputs, payload, didPayload.verificationMethod)
+
+		const value: MsgDeactivateDidDoc = {
+			payload,
+			signatures
+		}
+
+		const deactivateDidMsg: MsgDeactivateDidDocEncodeObject = {
+			typeUrl: typeUrlMsgDeactivateDidDoc,
+			value
+		}
+
+		return this._signer.signAndBroadcast(
+			address,
+			[deactivateDidMsg],
+			fee,
+			memo
+		)
+	}
 }
 
 export type MinimalImportableDIDModule = MinimalImportableCheqdSDKModule<DIDModule>

package/src/modules/resource.ts

@@ -2,9 +2,8 @@ import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
 import { CheqdSigningStargateClient } from "../signer"
 import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing"
 import { DidStdFee, IContext, ISignInputs } from '../types';
-import { MsgCreateResource, MsgCreateResourcePayload, MsgCreateResourceResponse, protobufPackage } from "@cheqd/ts-proto/resource/v1/tx"
+import { MsgCreateResource, MsgCreateResourcePayload, MsgCreateResourceResponse, protobufPackage } from "@cheqd/ts-proto/cheqd/resource/v2"
 import { DeliverTxResponse } from "@cosmjs/stargate"
-import { Writer } from "protobufjs"
 
 export const typeUrlMsgCreateResource = `/${protobufPackage}.MsgCreateResource`
 export const typeUrlMsgCreateResourceResponse = `/${protobufPackage}.MsgCreateResourceResponse`
@@ -35,36 +34,8 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		return []
 	}
 
-	// We need this workagound because amino encoding is used in cheqd-node to derive sign bytes for identity messages.
-	// In most cases it works the same way as protobuf encoding, but in the MsgCreateResourcePayload
-	// we use non-default property indexes so we need this separate encoding function.
-	// TODO: Remove this workaround when cheqd-node will use protobuf encoding.
-	static getMsgCreateResourcePayloadAminoSignBytes(message: MsgCreateResourcePayload): Uint8Array {
-		const writer = new Writer();
-
-		if (message.collectionId !== "") {
-			writer.uint32(10).string(message.collectionId);
-		}
-		if (message.id !== "") {
-			writer.uint32(18).string(message.id);
-		}
-		if (message.name !== "") {
-			writer.uint32(26).string(message.name);
-		}
-		if (message.resourceType !== "") {
-			writer.uint32(34).string(message.resourceType);
-		}
-		if (message.data.length !== 0) {
-			// Animo coded assigns index 5 to this property. In proto definitions it's 6.
-			// Since we use amino on node + non default property indexing, we need to encode it manually.
-			writer.uint32(42).bytes(message.data);
-		}
-
-		return writer.finish();
-	}
-
 	static async signPayload(payload: MsgCreateResourcePayload, signInputs: ISignInputs[]): Promise<MsgCreateResource> {
-		const signBytes = ResourceModule.getMsgCreateResourcePayloadAminoSignBytes(payload)
+		const signBytes = MsgCreateResourcePayload.encode(payload).finish()
 		const signatures = await CheqdSigningStargateClient.signIdentityTx(signBytes, signInputs)
 		
 		return {

package/src/signer.ts

@@ -3,11 +3,9 @@ import { EncodeObject, isOfflineDirectSigner, OfflineSigner, encodePubkey, TxBod
 import { DeliverTxResponse, GasPrice, HttpEndpoint, QueryClient, SigningStargateClient, SigningStargateClientOptions, calculateFee, SignerData } from "@cosmjs/stargate"
 import { Tendermint34Client } from "@cosmjs/tendermint-rpc"
 import { createDefaultCheqdRegistry } from "./registry"
-import { MsgCreateDidPayload, SignInfo, MsgUpdateDidPayload } from '@cheqd/ts-proto/cheqd/v1/tx';
+import { MsgCreateDidDocPayload, SignInfo, MsgUpdateDidDocPayload, MsgDeactivateDidDocPayload, VerificationMethod } from '@cheqd/ts-proto/cheqd/did/v2';
 import { DidStdFee, ISignInputs, TSignerAlgo, VerificationMethods } from './types';
-import { VerificationMethod } from '@cheqd/ts-proto/cheqd/v1/did'
 import { base64ToBytes, EdDSASigner, hexToBytes, Signer, ES256Signer, ES256KSigner } from 'did-jwt';
-import { toString } from 'uint8arrays'
 import { assert, assertDefined } from '@cosmjs/utils'
 import { encodeSecp256k1Pubkey } from '@cosmjs/amino'
 import { Int53 } from '@cosmjs/math'
@@ -198,30 +196,45 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 		return this.didSigners[verificationMethod]!
 	}
 
-	async signCreateDidTx(signInputs: ISignInputs[], payload: MsgCreateDidPayload): Promise<SignInfo[]> {
+	async signCreateDidTx(signInputs: ISignInputs[], payload: MsgCreateDidDocPayload): Promise<SignInfo[]> {
 		await this.checkDidSigners(payload?.verificationMethod)
 
-		const signBytes = MsgCreateDidPayload.encode(payload).finish()
+		const signBytes = MsgCreateDidDocPayload.encode(payload).finish()
 		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
 			return {
 				verificationMethodId: signInput.verificationMethodId,
 				// TODO: We can't rely on `payload.verificationMethod` here because `CreateResourceTx` doesn't have it
-				signature: toString(base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string), 'base64pad')
+				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
 			}
 		}))
 
 		return signInfos
 	}
 
-	async signUpdateDidTx(signInputs: ISignInputs[], payload: MsgUpdateDidPayload): Promise<SignInfo[]> {
+	async signUpdateDidTx(signInputs: ISignInputs[], payload: MsgUpdateDidDocPayload): Promise<SignInfo[]> {
 		await this.checkDidSigners(payload?.verificationMethod)
 
-		const signBytes = MsgUpdateDidPayload.encode(payload).finish()
+		const signBytes = MsgUpdateDidDocPayload.encode(payload).finish()
 		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
 			return {
 				verificationMethodId: signInput.verificationMethodId,
 				// TODO: We can't rely on `payload.verificationMethod` here because `CreateResourceTx` doesn't have it
-				signature: toString(base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string), 'base64pad')
+				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
+			}
+		}))
+
+		return signInfos
+	}
+
+	async signDeactivateDidTx(signInputs: ISignInputs[], payload: MsgDeactivateDidDocPayload, verificationMethod: VerificationMethod[]): Promise<SignInfo[]> {
+		await this.checkDidSigners(verificationMethod)
+
+		const signBytes = MsgDeactivateDidDocPayload.encode(payload).finish()
+		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
+			return {
+				verificationMethodId: signInput.verificationMethodId,
+				// TODO: We can't rely on `payload.verificationMethod` here because `CreateResourceTx` doesn't have it
+				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
 			}
 		}))
 
@@ -254,7 +267,7 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 
 			signInfos.push({
 				verificationMethodId: signInput.verificationMethodId,
-				signature: toString(base64ToBytes(signature), 'base64pad')
+				signature: base64ToBytes(signature)
 			});
 		}
 

package/src/types.ts

@@ -1,6 +1,7 @@
 import { CheqdSDK } from "."
 import { Coin } from "@cosmjs/proto-signing"
 import { Signer } from "did-jwt"
+import { MsgDeactivateDidDocPayload, VerificationMethod } from "@cheqd/ts-proto/cheqd/did/v2"
 
 export enum CheqdNetwork {
     Mainnet = 'mainnet',
@@ -66,4 +67,8 @@ export interface DidStdFee {
     readonly gas: string
     payer?: string
     granter?: string
+}
+
+export interface MsgDeactivateDidPayload extends MsgDeactivateDidDocPayload {
+    verificationMethod: VerificationMethod[]
 }

package/src/utils.ts

@@ -1,4 +1,8 @@
-import { VerificationMethod } from "@cheqd/ts-proto/cheqd/v1/did"
+import {
+    MsgCreateDidDocPayload,
+    MsgUpdateDidDocPayload,
+    VerificationMethod 
+} from "@cheqd/ts-proto/cheqd/did/v2"
 import { 
     IKeyPair, 
     IKeyValuePair, 
@@ -16,7 +20,7 @@ import { bases } from "multiformats/basics"
 import { base64ToBytes } from "did-jwt"
 import { generateKeyPair, generateKeyPairFromSeed, KeyPair } from '@stablelib/ed25519'
 import { v4 } from 'uuid'
-import { MsgCreateDidPayload, MsgUpdateDidPayload } from "@cheqd/ts-proto/cheqd/v1/tx"
+import { createHash } from 'crypto'
 
 export type TImportableEd25519Key = {
     publicKeyHex: string
@@ -25,11 +29,10 @@ export type TImportableEd25519Key = {
     type: "Ed25519"
 }
 
-export type IdentifierPayload = Partial<MsgCreateDidPayload> | Partial<MsgUpdateDidPayload>
+// multicodec ed25519-pub header as varint
+const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
 
-export function parseToKeyValuePair(object: { [key: string]: any }): IKeyValuePair[] {
-    return Object.entries(object).map(([key, value]) => ({ key, value }))
-}
+export type IdentifierPayload = Partial<MsgCreateDidDocPayload> | Partial<MsgUpdateDidDocPayload>
 
 export function isEqualKeyValuePair(kv1: IKeyValuePair[], kv2: IKeyValuePair[]): boolean {
     return kv1.every((item, index) => item.key === kv2[index].key && item.value === kv2[index].value)
@@ -44,7 +47,7 @@ export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519
         switch (method?.type) {
             case VerificationMethods.Base58:
                 const publicKeyMultibase = bases['base58btc'].encode(publicKey)
-                if (method.publicKeyMultibase === publicKeyMultibase) {
+                if ((JSON.parse(method.verificationMaterial)).publicKeyMultibase === publicKeyMultibase) {
                     return {
                         verificationMethodId: method.id,
                         privateKeyHex: key.privateKeyHex
@@ -52,12 +55,12 @@ export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519
                 }
 
             case VerificationMethods.JWK:
-                const publicKeyJWK = parseToKeyValuePair({
+                const publicKeyJWK = {
                     crv: 'Ed25519',
                     kty: 'OKP',
                     x: toString( publicKey, 'base64url' )
-                })
-                if (isEqualKeyValuePair(method.publicKeyJwk, publicKeyJWK)) {
+                }
+                if ((JSON.parse(method.verificationMaterial)).publicKeyJwk, publicKeyJWK) {
                     return {
                         verificationMethodId: method.id,
                         privateKeyHex: key.privateKeyHex
@@ -95,7 +98,7 @@ export function createVerificationKeys(keyPair: IKeyPair, algo: MethodSpecificId
     switch (algo) {
         case MethodSpecificIdAlgo.Base58:
             methodSpecificId = bases['base58btc'].encode(base64ToBytes(keyPair.publicKey))
-            didUrl = `did:cheqd:${network}:${methodSpecificId.substring(0, length)}`
+            didUrl = `did:cheqd:${network}:${(bases['base58btc'].encode((fromString(sha256(keyPair.publicKey))).slice(0,16))).slice(1)}`
             return {
                 methodSpecificId,
                 didUrl,
@@ -122,8 +125,10 @@ export function createDidVerificationMethod(verificationMethodTypes: Verificatio
                     id: verificationKeys[_].keyId,
                     type: type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyMultibase: verificationKeys[_].methodSpecificId,
-                    publicKeyJwk: []
+                    verificationMaterial: JSON.stringify({
+                        publicKeyMultibase: verificationKeys[_].methodSpecificId,
+                        publicKeyJwk: []
+                    })
                 }
 
             case VerificationMethods.JWK:
@@ -131,32 +136,33 @@ export function createDidVerificationMethod(verificationMethodTypes: Verificatio
                     id: verificationKeys[_].keyId,
                     type: type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyJwk: parseToKeyValuePair(
-                        {
+                    verificationMaterial: JSON.stringify({
+                        publicKeyJwk: {
                             crv: 'Ed25519',
                             kty: 'OKP',
                             x: toString( fromString( verificationKeys[_].publicKey, 'base64pad' ), 'base64url' )
-                        }
-                    ),
-                    publicKeyMultibase: ''
+                        },
+                        publicKeyMultibase: ''
+                    })
                 }
         }
     }) ?? []
 }
 
-export function createDidPayload(verificationMethods: VerificationMethod[], verificationKeys: IVerificationKeys[]): MsgCreateDidPayload {
+export function createDidPayload(verificationMethods: VerificationMethod[], verificationKeys: IVerificationKeys[]): MsgCreateDidDocPayload {
     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 MsgCreateDidDocPayload.fromPartial(
         {
             id: did,
             controller: verificationKeys.map(key => key.didUrl),
             verificationMethod: verificationMethods,
-            authentication: verificationKeys.map(key => key.keyId)
+            authentication: verificationKeys.map(key => key.keyId),
+            versionId: v4()
         }
     )
 }
@@ -172,7 +178,7 @@ export function createDidPayloadWithSignInputs(seed?: string, keys?: IKeyPair[])
     const verificationKeys = keys.map((key, i) => createVerificationKeys(key, key.algo || MethodSpecificIdAlgo.Base58, `key-${i}`))
     const verificationMethod = createDidVerificationMethod(verificationMethodTypes, verificationKeys)
     
-    let payload : Partial<MsgCreateDidPayload> = {
+    let payload : Partial<MsgCreateDidDocPayload> = {
         id: verificationKeys[0].didUrl,
         controller: verificationKeys.map(key => key.didUrl),
         verificationMethod: verificationMethod,
@@ -182,7 +188,7 @@ export function createDidPayloadWithSignInputs(seed?: string, keys?: IKeyPair[])
     const keyHexs = keys.map((key)=>convertKeyPairtoTImportableEd25519Key(key))
     const signInputs = keyHexs.map((key)=>createSignInputsFromImportableEd25519Key(key, verificationMethod))
 
-    return { didPayload: MsgCreateDidPayload.fromPartial(payload), keys, signInputs }
+    return { didPayload: MsgCreateDidDocPayload.fromPartial(payload), keys, signInputs }
 }
 
 export function convertKeyPairtoTImportableEd25519Key(keyPair: IKeyPair) : TImportableEd25519Key {
@@ -199,3 +205,18 @@ export function createSignInputsFromKeyPair(didDocument: IdentifierPayload, keys
     const signInputs = keyHexs.map((key)=>createSignInputsFromImportableEd25519Key(key, didDocument.verificationMethod!))
     return signInputs
 }
+
+function sha256(message: string) {
+    return createHash('sha256').update(message).digest('hex')
+}
+
+// encode a multibase base58-btc multicodec key
+// function _encodeMbKey(header: any, key: any) {
+//     const mbKey = new Uint8Array(header.length + key.length);
+  
+//     mbKey.set(header);
+//     mbKey.set(key, header.length);
+  
+//     return bases['base58btc'].encode(mbKey);
+//   }
+  

package/tests/modules/did.test.ts

@@ -1,7 +1,8 @@
-import { MsgUpdateDidPayload } from "@cheqd/ts-proto/cheqd/v1/tx"
+import { MsgUpdateDidDocPayload } from "@cheqd/ts-proto/cheqd/did/v2"
 import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"
 import { DeliverTxResponse } from "@cosmjs/stargate"
 import { fromString, toString } from 'uint8arrays'
+import { v4 } from "uuid"
 import { DIDModule } from "../../src"
 import { createDefaultCheqdRegistry } from "../../src/registry"
 import { CheqdSigningStargateClient } from "../../src/signer"
@@ -41,10 +42,10 @@ describe('DIDModule', () => {
                 amount: [
                     {
                         denom: 'ncheq',
-                        amount: '5000000'
+                        amount: '5000000000'
                     }
                 ],
-                gas: '100000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             const didTx: DeliverTxResponse = await didModule.createDidTx(
@@ -69,6 +70,7 @@ describe('DIDModule', () => {
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Uuid, 'key-1', 16)
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            didPayload.versionId = v4()
             const signInputs: ISignInputs[] = [
                 {
                     verificationMethodId: didPayload.verificationMethod[0].id,
@@ -79,10 +81,10 @@ describe('DIDModule', () => {
                 amount: [
                     {
                         denom: 'ncheq',
-                        amount: '5000000'
+                        amount: '5000000000'
                     }
                 ],
-                gas: '100000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             const didTx: DeliverTxResponse = await didModule.createDidTx(
@@ -120,10 +122,10 @@ describe('DIDModule', () => {
                 amount: [
                     {
                         denom: 'ncheq',
-                        amount: '5000000'
+                        amount: '5000000000'
                     }
                 ],
-                gas: '100000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             const didTx: DeliverTxResponse = await didModule.createDidTx(
@@ -139,7 +141,7 @@ describe('DIDModule', () => {
             expect(didTx.code).toBe(0)
 
             // Update the DID
-            const updateDidPayload = MsgUpdateDidPayload.fromPartial({
+            const updateDidPayload = MsgUpdateDidDocPayload.fromPartial({
                 context: didPayload.context,
                 id: didPayload.id,
                 controller: didPayload.controller,

package/tests/modules/resource.test.ts

@@ -6,7 +6,7 @@ import { createDefaultCheqdRegistry } from "../../src/registry"
 import { CheqdSigningStargateClient } from "../../src/signer"
 import { DidStdFee, ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from '../../src/types';
 import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, exampleCheqdNetwork, faucet } from "../testutils.test"
-import { MsgCreateResourcePayload } from '@cheqd/ts-proto/resource/v1/tx';
+import { MsgCreateResourcePayload } from '@cheqd/ts-proto/cheqd/resource/v2';
 import { randomUUID } from "crypto"
 
 const defaultAsyncTxTimeout = 30000
@@ -48,10 +48,10 @@ describe('ResourceModule', () => {
                 amount: [
                     {
                         denom: 'ncheq',
-                        amount: '50000000'
+                        amount: '2500000000'
                     }
                 ],
-                gas: '1000000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             
@@ -74,6 +74,8 @@ describe('ResourceModule', () => {
             const resourcePayload: MsgCreateResourcePayload = {
                 collectionId: didPayload.id.split(":").reverse()[0],
                 id: randomUUID(),
+                version: "1.0",
+                alsoKnownAs: [],
                 name: 'Test Resource',
                 resourceType: 'test-resource-type',
                 data: new TextEncoder().encode("{ \"message\": \"hello world\"}")

package/tests/signer.test.ts

@@ -1,8 +1,7 @@
-import { VerificationMethod } from "@cheqd/ts-proto/cheqd/v1/did"
-import { MsgCreateDid, MsgCreateDidPayload, SignInfo } from "@cheqd/ts-proto/cheqd/v1/tx"
+import { MsgCreateDidDoc, MsgCreateDidDocPayload, VerificationMethod } from "@cheqd/ts-proto/cheqd/did/v2"
 import { DirectSecp256k1HdWallet, Registry } from "@cosmjs/proto-signing"
-import { base64ToBytes, EdDSASigner } from "did-jwt"
-import { typeUrlMsgCreateDid } from '../src/modules/did'
+import { EdDSASigner } from "did-jwt"
+import { typeUrlMsgCreateDidDoc } from '../src/modules/did'
 import { CheqdSigningStargateClient } from "../src/signer"
 import { ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from "../src/types"
 import { fromString, toString } from 'uint8arrays'
@@ -42,9 +41,9 @@ describe('CheqdSigningStargateClient', () => {
         it('can be constructed with cheqd custom registry', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
             const registry = new Registry()
-            registry.register(typeUrlMsgCreateDid, MsgCreateDid)
+            registry.register(typeUrlMsgCreateDidDoc, MsgCreateDidDoc)
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet, { registry })
-            expect(signer.registry.lookupType(typeUrlMsgCreateDid)).toBe(MsgCreateDid)
+            expect(signer.registry.lookupType(typeUrlMsgCreateDidDoc)).toBe(MsgCreateDidDoc)
         })
     })
 
@@ -116,7 +115,7 @@ describe('CheqdSigningStargateClient', () => {
                 id: nonExistingKeyId,
                 type: nonExistingVerificationMethod,
                 controller: nonExistingDid,
-                publicKeyMultibase: nonExistingPublicKeyMultibase
+                verificationMaterial: JSON.stringify({publicKeyMultibase: nonExistingPublicKeyMultibase})
             }
 
             await expect(signer.checkDidSigners([VerificationMethod.fromPartial(verificationMethod)])).rejects.toThrow()
@@ -139,12 +138,12 @@ describe('CheqdSigningStargateClient', () => {
             ]
             const signInfos = await signer.signCreateDidTx(signInputs, didPayload)
             const publicKeyRaw = fromString(keyPair.publicKey, 'base64')
-            const messageRaw = MsgCreateDidPayload.encode(didPayload).finish()
-            const signatureRaw = base64ToBytes(signInfos[0].signature)
+            const messageRaw = MsgCreateDidDocPayload.encode(didPayload).finish()
+
             const verified = verify(
                 publicKeyRaw,
                 messageRaw,
-                signatureRaw
+                signInfos[0].signature
             )
 
             expect(verified).toBe(true)