@cheqd/sdk 1.4.0 → 1.5.0-develop.2

package/src/modules/did.ts

@@ -1,65 +1,98 @@
 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, MsgCreateDidPayload, MsgDeactivateDidPayload, MsgUpdateDidPayload, VerificationMethodPayload } from "../types"
+import { 
+	MsgCreateDidDoc, 
+	MsgCreateDidDocResponse, 
+	MsgDeactivateDidDoc, 
+	MsgDeactivateDidDocPayload, 
+	MsgDeactivateDidDocResponse, 
+	MsgUpdateDidDoc, 
+	MsgUpdateDidDocResponse, 
+	protobufPackage, 
+	SignInfo
+} 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],
+		[typeUrlMsgDeactivateDidDoc, MsgDeactivateDidDoc],
+		[typeUrlMsgDeactivateDidDocResponse, MsgDeactivateDidDocResponse],
     ]
 
 	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 +100,26 @@ 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[] | SignInfo[], didPayload: Partial<MsgCreateDidPayload>, 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 signatures = await this._signer.signCreateDidTx(signInputs, payload)
+		const payload = MsgCreateDidPayload.transformPayload(didPayload)
+		let signatures: SignInfo[]
+		if(ISignInputs.isSignInput(signInputs)) {
+			signatures = await this._signer.signCreateDidTx(signInputs, payload)
+		} else {
+			signatures = signInputs
+		}
 
-		const value: MsgCreateDid = {
+		const value: MsgCreateDidDoc = {
 			payload,
 			signatures
 		}
 
-		const createDidMsg: MsgCreateDidEncodeObject = {
-			typeUrl: typeUrlMsgCreateDid,
+		const createDidMsg: MsgCreateDidDocEncodeObject = {
+			typeUrl: typeUrlMsgCreateDidDoc,
 			value
 		}
 
@@ -93,21 +131,26 @@ 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[] | SignInfo[], didPayload: Partial<MsgUpdateDidPayload>, 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 signatures = await this._signer.signUpdateDidTx(signInputs, payload)
+		const payload = MsgCreateDidPayload.transformPayload(didPayload)
+		let signatures: SignInfo[]
+		if(ISignInputs.isSignInput(signInputs)) {
+			signatures = await this._signer.signUpdateDidTx(signInputs, payload)
+		} else {
+			signatures = signInputs
+		}
 
-		const value: MsgUpdateDid = {
+		const value: MsgUpdateDidDoc = {
 			payload,
 			signatures
 		}
 
-		const updateDidMsg: MsgUpdateDidEncodeObject = {
-			typeUrl: typeUrlMsgUpdateDid,
+		const updateDidMsg: MsgUpdateDidDocEncodeObject = {
+			typeUrl: typeUrlMsgUpdateDidDoc,
 			value
 		}
 
@@ -118,6 +161,37 @@ export class DIDModule extends AbstractCheqdSDKModule {
 			memo
 		)
 	}
+
+	async deactivateDidTx(signInputs: ISignInputs[] | SignInfo[], 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})
+		let signatures: SignInfo[]
+		if(ISignInputs.isSignInput(signInputs)) {
+			signatures = await this._signer.signDeactivateDidTx(signInputs, payload, didPayload.verificationMethod.map((e)=>VerificationMethodPayload.transformPayload(e)))
+		} else {
+			signatures = signInputs
+		}
+
+		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,9 @@ 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"
+import { SignInfo } from "@cheqd/ts-proto/cheqd/did/v2";
 
 export const typeUrlMsgCreateResource = `/${protobufPackage}.MsgCreateResource`
 export const typeUrlMsgCreateResourceResponse = `/${protobufPackage}.MsgCreateResourceResponse`
@@ -35,37 +35,14 @@ 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);
+	static async signPayload(payload: MsgCreateResourcePayload, signInputs: ISignInputs[] | SignInfo[]): Promise<MsgCreateResource> {
+		const signBytes = MsgCreateResourcePayload.encode(payload).finish()
+		let signatures: SignInfo[]
+		if(ISignInputs.isSignInput(signInputs)) {
+			signatures = await CheqdSigningStargateClient.signIdentityTx(signBytes, signInputs)
+		} else {
+			signatures = signInputs
 		}
-		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 signatures = await CheqdSigningStargateClient.signIdentityTx(signBytes, signInputs)
 		
 		return {
 			payload,
@@ -73,7 +50,7 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		}
 	}
 
-	async createResourceTx(signInputs: ISignInputs[], resourcePayload: Partial<MsgCreateResourcePayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async createResourceTx(signInputs: ISignInputs[] | SignInfo[], resourcePayload: Partial<MsgCreateResourcePayload>, address: string, fee: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}

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 { DidStdFee, ISignInputs, TSignerAlgo, VerificationMethods } from './types';
-import { VerificationMethod } from '@cheqd/ts-proto/cheqd/v1/did'
+import { MsgCreateDidDocPayload, SignInfo, MsgUpdateDidDocPayload, MsgDeactivateDidDocPayload, VerificationMethod } from '@cheqd/ts-proto/cheqd/did/v2';
+import { DidStdFee, ISignInputs, TSignerAlgo, VerificationMethodPayload, VerificationMethods } from './types';
 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'
@@ -178,11 +176,11 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 		}
 
 		verificationMethods.forEach((verificationMethod) => {
-			if (!(Object.values(VerificationMethods) as string[]).includes(verificationMethod.type ?? '')) {
-				throw new Error(`Unsupported verification method type: ${verificationMethod.type}`)
+			if (!(Object.values(VerificationMethods) as string[]).includes(verificationMethod.verificationMethodType ?? '')) {
+				throw new Error(`Unsupported verification method type: ${verificationMethod.verificationMethodType}`)
 			}
-			if (!this.didSigners[verificationMethod.type ?? '']) {
-				this.didSigners[verificationMethod.type ?? ''] = EdDSASigner
+			if (!this.didSigners[verificationMethod.verificationMethodType ?? '']) {
+				this.didSigners[verificationMethod.verificationMethodType ?? ''] = EdDSASigner
 			}
 		})
 
@@ -191,37 +189,52 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 
 	async getDidSigner(verificationMethodId: string, verificationMethods: Partial<VerificationMethod>[]): Promise<(secretKey: Uint8Array) => Signer> {
 		await this.checkDidSigners(verificationMethods)
-		const verificationMethod = verificationMethods.find(method => method.id === verificationMethodId)?.type
+		const verificationMethod = verificationMethods.find(method => method.id === verificationMethodId)?.verificationMethodType
 		if (!verificationMethod) {
 			throw new Error(`Verification method for ${verificationMethodId} not found`)
 		}
 		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,8 @@
 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 enum CheqdNetwork {
     Mainnet = 'mainnet',
@@ -18,7 +20,8 @@ export interface IContext {
 }
 
 export enum VerificationMethods {
-    Base58 = 'Ed25519VerificationKey2020',
+    Ed255192020 = 'Ed25519VerificationKey2020',
+    Ed255192018 = 'Ed25519VerificationKey2018',
     JWK = 'JsonWebKey2020',
 }
 
@@ -37,6 +40,12 @@ 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
@@ -66,4 +75,153 @@ export interface DidStdFee {
     readonly gas: string
     payer?: string
     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[]
+}