@cheqd/sdk 1.4.0 → 1.5.0-develop.2

package/src/utils.ts

@@ -1,4 +1,3 @@
-import { VerificationMethod } from "@cheqd/ts-proto/cheqd/v1/did"
 import { 
     IKeyPair, 
     IKeyValuePair, 
@@ -9,14 +8,17 @@ import {
     TVerificationKey, 
     TVerificationKeyPrefix, 
     CheqdNetwork, 
-    IVerificationKeys 
+    IVerificationKeys, 
+    MsgCreateDidPayload,
+    VerificationMethodPayload,
+    MsgUpdateDidPayload
 } from "./types"
 import { fromString, toString } from 'uint8arrays'
 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,43 +27,53 @@ 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<MsgCreateDidPayload> | Partial<MsgUpdateDidPayload>
 
 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: VerificationMethod[]): ISignInputs {
+export function createSignInputsFromImportableEd25519Key(key: TImportableEd25519Key, verificationMethod: VerificationMethodPayload[]): ISignInputs {
     if (verificationMethod?.length === 0) throw new Error('No verification methods provided')
 
     const publicKey = fromString(key.publicKeyHex, 'hex')
 
     for(const method of verificationMethod) {
         switch (method?.type) {
-            case VerificationMethods.Base58:
-                const publicKeyMultibase = bases['base58btc'].encode(publicKey)
+            case VerificationMethods.Ed255192020:
+                const publicKeyMultibase = _encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, 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) {
+                    return {
+                        verificationMethodId: method.id,
+                        privateKeyHex: key.privateKeyHex
+                    }
+                }
 
             case VerificationMethods.JWK:
-                const publicKeyJWK = parseToKeyValuePair({
+                const publicKeyJWK: any = {
                     crv: 'Ed25519',
                     kty: 'OKP',
                     x: toString( publicKey, 'base64url' )
-                })
-                if (isEqualKeyValuePair(method.publicKeyJwk, 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}`)
                 }
         }
     }
@@ -89,62 +101,70 @@ export function createKeyPairHex(seed?: string): IKeyPair {
     }
 }
 
-export function createVerificationKeys(keyPair: IKeyPair, algo: MethodSpecificIdAlgo, key: TVerificationKey<TVerificationKeyPrefix, number>, length: number = 32, network: CheqdNetwork = CheqdNetwork.Testnet): IVerificationKeys {
+export function createVerificationKeys(publicKey: string, algo: MethodSpecificIdAlgo, key: TVerificationKey<TVerificationKeyPrefix, number>, network: CheqdNetwork = CheqdNetwork.Testnet): IVerificationKeys {
     let methodSpecificId: TMethodSpecificId
     let didUrl: IVerificationKeys['didUrl']
+    
+    publicKey = isBase64(publicKey) ? publicKey : toString(fromString(publicKey, 'hex'), 'base64')
     switch (algo) {
         case MethodSpecificIdAlgo.Base58:
-            methodSpecificId = bases['base58btc'].encode(base64ToBytes(keyPair.publicKey))
-            didUrl = `did:cheqd:${network}:${methodSpecificId.substring(0, length)}`
+            methodSpecificId = bases['base58btc'].encode(base64ToBytes(publicKey))
+            didUrl = `did:cheqd:${network}:${(bases['base58btc'].encode((fromString(sha256(publicKey))).slice(0,16))).slice(1)}`
             return {
                 methodSpecificId,
                 didUrl,
                 keyId: `${didUrl}#${key}`,
-                publicKey: keyPair.publicKey,
+                publicKey,
             }
         case MethodSpecificIdAlgo.Uuid:
-            methodSpecificId = bases['base58btc'].encode(base64ToBytes(keyPair.publicKey))
+            methodSpecificId = bases['base58btc'].encode(base64ToBytes(publicKey))
             didUrl = `did:cheqd:${network}:${v4()}`
             return {
                 methodSpecificId,
                 didUrl,
                 keyId: `${didUrl}#${key}`,
-                publicKey: keyPair.publicKey,
+                publicKey,
             }
     }
 }
 
-export function createDidVerificationMethod(verificationMethodTypes: VerificationMethods[], verificationKeys: IVerificationKeys[]): VerificationMethod[] {
+const isBase64 = (value: string) => /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(value);
+
+export function createDidVerificationMethod(verificationMethodTypes: VerificationMethods[], verificationKeys: IVerificationKeys[]): VerificationMethodPayload[] {
     return verificationMethodTypes.map((type, _) => {
         switch (type) {
-            case VerificationMethods.Base58:
+            case VerificationMethods.Ed255192020:
                 return {
                     id: verificationKeys[_].keyId,
-                    type: type,
+                    type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyMultibase: verificationKeys[_].methodSpecificId,
-                    publicKeyJwk: []
+                    publicKeyMultibase: _encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, base64ToBytes(verificationKeys[_].publicKey))
+                }
+            
+            case VerificationMethods.Ed255192018:
+                return {
+                    id: verificationKeys[_].keyId,
+                    type,
+                    controller: verificationKeys[_].didUrl,
+                    publicKeyBase58: verificationKeys[_].methodSpecificId.slice(1)
                 }
 
             case VerificationMethods.JWK:
                 return {
                     id: verificationKeys[_].keyId,
-                    type: type,
+                    type,
                     controller: verificationKeys[_].didUrl,
-                    publicKeyJwk: parseToKeyValuePair(
-                        {
-                            crv: 'Ed25519',
-                            kty: 'OKP',
-                            x: toString( fromString( verificationKeys[_].publicKey, 'base64pad' ), 'base64url' )
-                        }
-                    ),
-                    publicKeyMultibase: ''
+                    publicKeyJWK: {
+                        crv: 'Ed25519',
+                        kty: 'OKP',
+                        x: toString( fromString( verificationKeys[_].publicKey, 'base64pad' ), 'base64url' )
+                    }
                 }
         }
     }) ?? []
 }
 
-export function createDidPayload(verificationMethods: VerificationMethod[], verificationKeys: IVerificationKeys[]): MsgCreateDidPayload {
+export function createDidPayload(verificationMethods: VerificationMethodPayload[], verificationKeys: IVerificationKeys[]): MsgCreateDidPayload {
     if (!verificationMethods || verificationMethods.length === 0)
         throw new Error('No verification methods provided')
     if (!verificationKeys || verificationKeys.length === 0)
@@ -156,46 +176,23 @@ export function createDidPayload(verificationMethods: VerificationMethod[], veri
             id: did,
             controller: verificationKeys.map(key => key.didUrl),
             verificationMethod: verificationMethods,
-            authentication: verificationKeys.map(key => key.keyId)
+            authentication: verificationKeys.map(key => key.keyId),
+            versionId: v4()
         }
     )
 }
 
-export function createDidPayloadWithSignInputs(seed?: string, keys?: IKeyPair[]) {
-    if(seed && keys) throw new Error ('Only one of seed or keys should be passed as an argument')
-    
-    if(!keys) {
-        keys = [seed ? createKeyPairBase64(seed) : createKeyPairBase64()]
-    }
-
-    const verificationMethodTypes = keys.map((key) => !key.algo || key.algo == MethodSpecificIdAlgo.Base58 ? VerificationMethods.Base58 : VerificationMethods.JWK)
-    const verificationKeys = keys.map((key, i) => createVerificationKeys(key, key.algo || MethodSpecificIdAlgo.Base58, `key-${i}`))
-    const verificationMethod = createDidVerificationMethod(verificationMethodTypes, verificationKeys)
-    
-    let payload : Partial<MsgCreateDidPayload> = {
-        id: verificationKeys[0].didUrl,
-        controller: verificationKeys.map(key => key.didUrl),
-        verificationMethod: verificationMethod,
-        authentication: verificationKeys.map(key => key.keyId),
-    }
-
-    const keyHexs = keys.map((key)=>convertKeyPairtoTImportableEd25519Key(key))
-    const signInputs = keyHexs.map((key)=>createSignInputsFromImportableEd25519Key(key, verificationMethod))
-
-    return { didPayload: MsgCreateDidPayload.fromPartial(payload), keys, signInputs }
-}
-
-export function convertKeyPairtoTImportableEd25519Key(keyPair: IKeyPair) : TImportableEd25519Key {
-    return {
-        type: 'Ed25519',
-        privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex'),
-        kid: 'kid',
-        publicKeyHex: toString(fromString(keyPair.publicKey, 'base64'), 'hex')
-    }
+function sha256(message: string) {
+    return createHash('sha256').update(message).digest('hex')
 }
 
-export function createSignInputsFromKeyPair(didDocument: IdentifierPayload, keys: IKeyPair[]) {
-    const keyHexs = keys.map((key)=>convertKeyPairtoTImportableEd25519Key(key))
-    const signInputs = keyHexs.map((key)=>createSignInputsFromImportableEd25519Key(key, didDocument.verificationMethod!))
-    return signInputs
+// 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);
 }
+  

package/tests/modules/did.test.ts

@@ -1,11 +1,12 @@
-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"
-import { DidStdFee, ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from "../../src/types"
+import { DidStdFee, ISignInputs, MethodSpecificIdAlgo, MsgCreateDidPayload, MsgDeactivateDidPayload, VerificationMethods } from "../../src/types"
 import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, exampleCheqdNetwork, faucet } from "../testutils.test"
 
 const defaultAsyncTxTimeout = 30000
@@ -28,7 +29,7 @@ describe('DIDModule', () => {
             const didModule = new DIDModule(signer)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.JWK], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
 
             const signInputs: ISignInputs[] = [
@@ -44,7 +45,7 @@ describe('DIDModule', () => {
                         amount: '5000000'
                     }
                 ],
-                gas: '100000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             const didTx: DeliverTxResponse = await didModule.createDidTx(
@@ -67,8 +68,9 @@ describe('DIDModule', () => {
             const didModule = new DIDModule(signer)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Uuid, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            didPayload.versionId = v4()
             const signInputs: ISignInputs[] = [
                 {
                     verificationMethodId: didPayload.verificationMethod[0].id,
@@ -82,7 +84,7 @@ describe('DIDModule', () => {
                         amount: '5000000'
                     }
                 ],
-                gas: '100000',
+                gas: '200000',
                 payer: (await wallet.getAccounts())[0].address
             } 
             const didTx: DeliverTxResponse = await didModule.createDidTx(
@@ -108,7 +110,7 @@ describe('DIDModule', () => {
             
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
             const signInputs: ISignInputs[] = [
                 {
@@ -123,7 +125,7 @@ describe('DIDModule', () => {
                         amount: '5000000'
                     }
                 ],
-                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 = MsgCreateDidPayload.fromPartial({
                 context: didPayload.context,
                 id: didPayload.id,
                 controller: didPayload.controller,
@@ -160,4 +162,62 @@ describe('DIDModule', () => {
             expect(updateDidTx.code).toBe(0)
         }, defaultAsyncTxTimeout)
     })
+
+    describe('deactivateDidTx', () => {
+        it('should deactivate a DID', async () => {
+            const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
+            const registry = createDefaultCheqdRegistry(DIDModule.registryTypes)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet, { registry })
+            const didModule = new DIDModule(signer)
+            
+            const keyPair = createKeyPairBase64()
+            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            const signInputs: ISignInputs[] = [
+                {
+                    verificationMethodId: didPayload.verificationMethod[0].id,
+                    privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
+                }
+            ]
+            const fee: DidStdFee = {
+                amount: [
+                    {
+                        denom: 'ncheq',
+                        amount: '5000000'
+                    }
+                ],
+                gas: '200000',
+                payer: (await wallet.getAccounts())[0].address
+            } 
+            const didTx: DeliverTxResponse = await didModule.createDidTx(
+                signInputs,
+                didPayload,
+                (await wallet.getAccounts())[0].address,
+                fee
+            )
+
+            console.warn(`Using payload: ${JSON.stringify(didPayload)}`)
+            console.warn(`DID Tx: ${JSON.stringify(didTx)}`)
+
+            expect(didTx.code).toBe(0)
+
+            // Update the DID
+            const deactivateDidPayload: MsgDeactivateDidPayload = {
+                id: didPayload.id,
+                verificationMethod: didPayload.verificationMethod,
+                versionId: v4()
+            }
+
+            const deactivateDidTx: DeliverTxResponse = await didModule.deactivateDidTx(
+                signInputs,
+                deactivateDidPayload,
+                (await wallet.getAccounts())[0].address,
+                fee
+            )
+
+            console.warn(deactivateDidTx)
+            expect(deactivateDidTx.code).toBe(0)
+        }, defaultAsyncTxTimeout)
+    })
 })

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
@@ -34,7 +34,7 @@ describe('ResourceModule', () => {
 
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
 
             const signInputs: ISignInputs[] = [
@@ -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,10 +1,9 @@
-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 { ISignInputs, MethodSpecificIdAlgo, MsgCreateDidPayload, VerificationMethods } from "../src/types"
 import { fromString, toString } from 'uint8arrays'
 import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, exampleCheqdNetwork, faucet } from "./testutils.test"
 import { verify } from "@stablelib/ed25519"
@@ -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)
         })
     })
 
@@ -54,8 +53,8 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
-            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys]))
             const didSigner = await signer.getDidSigner(didPayload.verificationMethod[0].id, didPayload.verificationMethod)
 
             expect(didSigner).toBe(EdDSASigner)
@@ -73,7 +72,7 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
             await expect(signer.getDidSigner(nonExistingKeyId, didPayload.verificationMethod)).rejects.toThrow()
         })
@@ -85,12 +84,12 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
-            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys]))
 
             const didSigners = await signer.checkDidSigners(didPayload.verificationMethod)
 
-            expect(didSigners[VerificationMethods.Base58]).toBe(EdDSASigner)
+            expect(didSigners[VerificationMethods.Ed255192020]).toBe(EdDSASigner)
         })
 
         it('should instantiate multiple signers for a did with multiple verification methods', async () => {
@@ -98,15 +97,18 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const keyPair1 = createKeyPairBase64()
             const keyPair2 = createKeyPairBase64()
+            const keyPair3 = createKeyPairBase64()
             const verificationKeys1 = createVerificationKeys(keyPair1, MethodSpecificIdAlgo.Base58, 'key-1', 16)
             const verificationKeys2 = createVerificationKeys(keyPair2, MethodSpecificIdAlgo.Base58, 'key-2', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58, VerificationMethods.JWK], [verificationKeys1, verificationKeys2])
-            const didPayload = createDidPayload(verificationMethods, [verificationKeys1, verificationKeys2])
+            const verificationKeys3 = createVerificationKeys(keyPair3, MethodSpecificIdAlgo.Base58, 'key-3', 16)
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020, VerificationMethods.JWK, VerificationMethods.Ed255192018], [verificationKeys1, verificationKeys2, verificationKeys3])
+            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys1, verificationKeys2, verificationKeys3]))
 
             const didSigners = await signer.checkDidSigners(didPayload.verificationMethod)
 
-            expect(didSigners[VerificationMethods.Base58]).toBe(EdDSASigner)
+            expect(didSigners[VerificationMethods.Ed255192020]).toBe(EdDSASigner)
             expect(didSigners[VerificationMethods.JWK]).toBe(EdDSASigner)
+            expect(didSigners[VerificationMethods.Ed255192018]).toBe(EdDSASigner)
         })
 
         it('should throw for non-supported verification method', async () => {
@@ -114,9 +116,9 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const verificationMethod: Partial<VerificationMethod> = {
                 id: nonExistingKeyId,
-                type: nonExistingVerificationMethod,
+                verificationMethodType: nonExistingVerificationMethod,
                 controller: nonExistingDid,
-                publicKeyMultibase: nonExistingPublicKeyMultibase
+                verificationMaterial: JSON.stringify({publicKeyMultibase: nonExistingPublicKeyMultibase})
             }
 
             await expect(signer.checkDidSigners([VerificationMethod.fromPartial(verificationMethod)])).rejects.toThrow()
@@ -129,8 +131,8 @@ describe('CheqdSigningStargateClient', () => {
             const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
             const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationMethods = createDidVerificationMethod([VerificationMethods.Base58], [verificationKeys])
-            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = MsgCreateDidPayload.transformPayload(MsgCreateDidPayload.fromPartial(createDidPayload(verificationMethods, [verificationKeys])))
             const signInputs: ISignInputs[] = [
                 {
                     verificationMethodId: didPayload.verificationMethod[0].id,
@@ -139,12 +141,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)