@cheqd/sdk 1.0.0 → 1.1.0

package/.releaserc.json

@@ -28,7 +28,8 @@
                     { "type": "revert", "release": false },
                     { "type": "style", "release": false },
                     { "type": "test", "release": false },
-                    { "scope": "no-release", "release": false }
+                    { "scope": "no-release", "release": false },
+                    { "scope": "release", "release": "patch" }
                 ],
                 "presetConfig": true
             }

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.1.0](https://github.com/cheqd/sdk/compare/1.0.0...1.1.0) (2022-07-29)
+
+
+### Features
+
+* **registry:** Fixed registration logic & improved extensibility ([3d76466](https://github.com/cheqd/sdk/commit/3d76466e322657817d380bf384d9f6c45c1eb793))
+
 ## 1.0.0 (2022-07-28)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheqd/sdk",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A TypeScript SDK built with CosmJS to interact with cheqd network ledger",
   "licence": "Apache-2.0",
   "author": "Cheqd Foundation Limited (https://github.com/cheqd)",

package/src/index.ts

@@ -1,90 +1,103 @@
-import { OfflineSigner } from '@cosmjs/proto-signing';
+import { GeneratedType, OfflineSigner, Registry } from '@cosmjs/proto-signing'
 import { DIDModule, MinimalImportableDIDModule } from './modules/did'
 import { MinimalImportableResourcesModule, ResourcesModule } from './modules/resources'
-import { AbstractCheqdSDKModule, applyMixins, instantiateCheqdSDKModule, } from './modules/_'
+import { AbstractCheqdSDKModule, applyMixins, instantiateCheqdSDKModule, instantiateCheqdSDKModuleRegistryTypes, } from './modules/_'
+import { createDefaultCheqdRegistry } from './registry'
 import { CheqdSigningStargateClient } from './signer'
 import { CheqdNetwork, IContext, IModuleMethodMap } from './types'
 
 export interface ICheqdSDKOptions {
-    modules: AbstractCheqdSDKModule[]
-    authorizedMethods?: string[]
-    network?: CheqdNetwork
-    rpcUrl: string
-    readonly wallet: OfflineSigner
+	modules: AbstractCheqdSDKModule[]
+	authorizedMethods?: string[]
+	network?: CheqdNetwork
+	rpcUrl: string
+	readonly wallet: OfflineSigner
 }
 
 export type DefaultCheqdSDKModules = MinimalImportableDIDModule & MinimalImportableResourcesModule
 
-export interface CheqdSDK extends DefaultCheqdSDKModules {}
+export interface CheqdSDK extends DefaultCheqdSDKModules { }
 
 export class CheqdSDK {
-    methods: IModuleMethodMap
-    signer: CheqdSigningStargateClient
-    options: ICheqdSDKOptions
-    private protectedMethods: string[] = ['constructor', 'build', 'loadModules']
-
-    constructor(options: ICheqdSDKOptions) {
-        if (!options?.wallet) {
-            throw new Error('No wallet provided')
-        }
-
-        this.options = {
-            authorizedMethods: [],
-            network: CheqdNetwork.Testnet,
-            ...options
-        }
-
-        this.methods = {}
-        this.signer = new CheqdSigningStargateClient(undefined, this.options.wallet, {})
+	methods: IModuleMethodMap
+	signer: CheqdSigningStargateClient
+	options: ICheqdSDKOptions
+	private protectedMethods: string[] = ['constructor', 'build', 'loadModules', 'loadRegistry']
+
+	constructor(options: ICheqdSDKOptions) {
+		if (!options?.wallet) {
+			throw new Error('No wallet provided')
+		}
+
+		this.options = {
+			authorizedMethods: [],
+			network: CheqdNetwork.Testnet,
+			...options
+		}
+
+		this.methods = {}
+		this.signer = new CheqdSigningStargateClient(undefined, this.options.wallet, {})
+	}
+
+	async execute<P = any, R = any>(method: string, ...params: P[]): Promise<R> {
+		if (!Object.keys(this.methods).includes(method)) {
+			throw new Error(`Method ${method} is not authorized`)
+		}
+		return await this.methods[method](...params, { sdk: this } as IContext)
+	}
+
+	private loadModules(modules: AbstractCheqdSDKModule[]): CheqdSDK {
+		this.options.modules = this.options.modules.map((module: any) => instantiateCheqdSDKModule(module, this.signer, { sdk: this } as IContext) as unknown as AbstractCheqdSDKModule)
+
+		const methods = applyMixins(this, modules)
+		this.methods = { ...this.methods, ...filterUnauthorizedMethods(methods, this.options.authorizedMethods || [], this.protectedMethods) }
+
+		for (const method of Object.keys(this.methods)) {
+			// @ts-ignore
+			this[method] = async (...params: any[]) => {
+				return await this.execute(method, ...params)
+			}
+		}
+
+		return this
+	}
+
+    private loadRegistry(): Registry {
+        const registryTypes = this.options.modules.map((module: any) => instantiateCheqdSDKModuleRegistryTypes(module)).reduce((acc, types) => {
+            return [...acc, ...types]
+        })
+        return createDefaultCheqdRegistry(registryTypes)
     }
 
-    async execute<P = any, R = any>(method: string, ...params: P[]): Promise<R> {
-        if (!Object.keys(this.methods).includes(method)) {
-            throw new Error(`Method ${method} is not authorized`)
-        }
-        return await this.methods[method](...params, { sdk: this } as IContext)
-    }
-
-    private loadModules(modules: AbstractCheqdSDKModule[]): CheqdSDK {
-        this.options.modules = this.options.modules.map((module: any) => instantiateCheqdSDKModule(module, this.signer, { sdk: this } as IContext) as unknown as AbstractCheqdSDKModule)
+	async build(): Promise<CheqdSDK> {
+        const registry = this.loadRegistry()
 
-        const methods = applyMixins(this, modules)
-        this.methods = { ...this.methods, ...filterUnauthorizedMethods(methods, this.options.authorizedMethods || [], this.protectedMethods) }
-
-        for(const method of Object.keys(this.methods)) {
-            // @ts-ignore
-            this[method] = async (...params: any[]) => {
-                return await this.execute(method, ...params)
+		this.signer = await CheqdSigningStargateClient.connectWithSigner(
+			this.options.rpcUrl,
+			this.options.wallet,
+            {
+                registry,
             }
-        }
+		)
 
-        return this
-    }
-
-    async build() {
-        this.signer = await CheqdSigningStargateClient.connectWithSigner(
-            this.options.rpcUrl,
-            this.options.wallet
-        )
-
-        return this.loadModules(this.options.modules)
-    }
+		return this.loadModules(this.options.modules)
+	}
 }
 
 export function filterUnauthorizedMethods(methods: IModuleMethodMap, authorizedMethods: string[], protectedMethods: string[]): IModuleMethodMap {
-    let _methods = Object.keys(methods)
-    if (authorizedMethods.length === 0) 
-        return _methods
-                .filter(method => !protectedMethods.includes(method))
-                .reduce((acc, method) => ({ ...acc, [method]: methods[method] }), {})
-
-    return _methods
-            .filter(method => authorizedMethods.includes(method) && !protectedMethods.includes(method))
-            .reduce((acc, method) => ({ ...acc, [method]: methods[method] }), {})
+	let _methods = Object.keys(methods)
+	if (authorizedMethods.length === 0)
+		return _methods
+			.filter(method => !protectedMethods.includes(method))
+			.reduce((acc, method) => ({ ...acc, [method]: methods[method] }), {})
+
+	return _methods
+		.filter(method => authorizedMethods.includes(method) && !protectedMethods.includes(method))
+		.reduce((acc, method) => ({ ...acc, [method]: methods[method] }), {})
 }
 
 export async function createCheqdSDK(options: ICheqdSDKOptions): Promise<CheqdSDK> {
-    return await (new CheqdSDK(options)).build()
+	return await (new CheqdSDK(options)).build()
 }
 
-export { DIDModule, ResourcesModule }
+export { DIDModule, ResourcesModule }

package/src/modules/_.ts

@@ -2,57 +2,62 @@ import { GeneratedType, Registry } from "@cosmjs/proto-signing"
 import { QueryClient } from "@cosmjs/stargate"
 import { CheqdSigningStargateClient } from '../signer'
 import { IModuleMethodMap } from "../types"
-import { setupDidExtension } from './did'
+import { DIDModule, setupDidExtension } from './did'
 
 export abstract class AbstractCheqdSDKModule {
-    _signer: CheqdSigningStargateClient
-    methods: IModuleMethodMap = {}
-    readonly _protectedMethods: string[] = ['constructor', 'exportMethods', 'registryTypes']
-
-    constructor(signer: CheqdSigningStargateClient) {
-        if (!signer) {
-            throw new Error("signer is required")
-        }
-        this._signer = signer
-    }
-
-    static registryTypes(): Iterable<[string, GeneratedType]> {
-        return []
-    }
+	_signer: CheqdSigningStargateClient
+	methods: IModuleMethodMap = {}
+	readonly _protectedMethods: string[] = ['constructor', 'getRegistryTypes']
+	static readonly registryTypes: Iterable<[string, GeneratedType]> = []
+
+	constructor(signer: CheqdSigningStargateClient) {
+		if (!signer) {
+			throw new Error("signer is required")
+		}
+		this._signer = signer
+	}
+
+    abstract getRegistryTypes(): Iterable<[string, GeneratedType]>
 }
 
-export type MinimalImportableCheqdSDKModule<T extends AbstractCheqdSDKModule> = Omit<T, '_signer' | '_protectedMethods'>
+type ProtectedMethods<T extends AbstractCheqdSDKModule, K extends keyof T> = T[K] extends string[] ? T[K][number] : T[K]
+
+export type MinimalImportableCheqdSDKModule<T extends AbstractCheqdSDKModule> = Omit<T, '_signer' | '_protectedMethods' | 'registryTypes' | 'getRegistryTypes'>
 
 export function instantiateCheqdSDKModule<T extends new (...args: any[]) => T>(module: T, ...args: ConstructorParameters<T>): T {
-    return new module(...args)
+	return new module(...args)
+}
+
+export function instantiateCheqdSDKModuleRegistryTypes(module: any): Iterable<[string, GeneratedType]> {
+    return module.registryTypes ?? []
 }
 
 export function applyMixins(derivedCtor: any, constructors: any[]): IModuleMethodMap {
-    let methods: IModuleMethodMap = {}
+	let methods: IModuleMethodMap = {}
 
-    constructors.forEach((baseCtor) => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
-            const property = baseCtor.prototype[name]
-            if (typeof property !== 'function' || derivedCtor.hasOwnProperty(name) || derivedCtor?.protectedMethods.includes(name) || baseCtor.prototype?._protectedMethods?.includes(name)) return
+	constructors.forEach((baseCtor) => {
+		Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+			const property = baseCtor.prototype[name]
+			if (typeof property !== 'function' || derivedCtor.hasOwnProperty(name) || derivedCtor?.protectedMethods.includes(name) || baseCtor.prototype?._protectedMethods?.includes(name)) return
 
-            methods = { ...methods, [name]: property }
-        });
-    });
+			methods = { ...methods, [name]: property }
+		});
+	});
 
-    return methods
+	return methods
 }
 
 export type CheqdExtension<K extends string, V = any> = {
-    [P in K]: (Record<P, V> & Partial<Record<Exclude<K, P>, never>>) extends infer O
-    ? { [Q in keyof O]: O[Q] }
-    : never
+	[P in K]: (Record<P, V> & Partial<Record<Exclude<K, P>, never>>) extends infer O
+	? { [Q in keyof O]: O[Q] }
+	: never
 }[K]
 
 export type CheqdExtensions = CheqdExtension<'did' | 'resources', any>
 
 export const setupCheqdExtensions = (base: QueryClient): CheqdExtensions => {
-    return {
-        ...setupDidExtension(base),
-        /** setupResourcesExtension(base) */
-    }
-}
+	return {
+		...setupDidExtension(base),
+		/** setupResourcesExtension(base) */
+	}
+}

package/src/modules/did.ts

@@ -1,87 +1,139 @@
-import { createProtobufRpcClient, DeliverTxResponse, QueryClient, StdFee } from "@cosmjs/stargate"
+import { createProtobufRpcClient, DeliverTxResponse, QueryClient } from "@cosmjs/stargate"
 /* import { QueryClientImpl } from '@cheqd/ts-proto/cheqd/v1/query' */
 import { CheqdExtension, AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
 import { CheqdSigningStargateClient } from "../signer"
 import { DidStdFee, IContext, ISignInputs } from "../types"
-import { MsgCreateDid, MsgCreateDidPayload, MsgUpdateDid, MsgUpdateDidPayload } from "@cheqd/ts-proto/cheqd/v1/tx"
-import { MsgCreateDidEncodeObject, MsgUpdateDidEncodeObject, typeUrlMsgCreateDid, typeUrlMsgUpdateDid } from "../registry"
+import { MsgCreateDid, MsgCreateDidPayload, MsgCreateDidResponse, MsgUpdateDid, MsgUpdateDidPayload, MsgUpdateDidResponse, protobufPackage } from "@cheqd/ts-proto/cheqd/v1/tx"
+import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing"
 
-export class DIDModule extends AbstractCheqdSDKModule {
-    constructor(signer: CheqdSigningStargateClient){
-        super(signer)
-        this.methods = {
-            createDidTx: this.createDidTx.bind(this),
-            updateDidTx: this.updateDidTx.bind(this)
-        }
-    }
+export const typeUrlMsgCreateDid = `/${protobufPackage}.MsgCreateDid`
+export const typeUrlMsgCreateDidResponse = `/${protobufPackage}.MsgCreateDidResponse`
+export const typeUrlMsgUpdateDid = `/${protobufPackage}.MsgUpdateDid`
+export const typeUrlMsgUpdateDidResponse = `/${protobufPackage}.MsgUpdateDidResponse`
 
-    async createDidTx(signInputs: ISignInputs[], 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 value: MsgCreateDid = {
-            payload,
-            signatures
-        }
-
-        const createDidMsg: MsgCreateDidEncodeObject = {
-            typeUrl: typeUrlMsgCreateDid,
-            value
-        }
-
-        return this._signer.signAndBroadcast(
-            address,
-            [createDidMsg],
-            fee,
-            memo
-        )
-    }
+export interface MsgCreateDidEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgCreateDid,
+	readonly value: Partial<MsgCreateDid>
+}
+
+export function isMsgCreateDidEncodeObject(obj: EncodeObject): obj is MsgCreateDidEncodeObject {
+	return obj.typeUrl === typeUrlMsgCreateDid
+}
+
+export interface MsgCreateDidResponseEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgCreateDidResponse,
+	readonly value: Partial<MsgCreateDidResponse>
+}
+
+export function MsgCreateDidResponseEncodeObject(obj: EncodeObject): obj is MsgCreateDidResponseEncodeObject {
+	return obj.typeUrl === typeUrlMsgCreateDidResponse
+}
+
+export interface MsgUpdateDidEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgUpdateDid,
+	readonly value: Partial<MsgUpdateDid>
+}
+
+export function MsgUpdateDidEncodeObject(obj: EncodeObject): obj is MsgUpdateDidEncodeObject {
+	return obj.typeUrl === typeUrlMsgUpdateDid
+}
 
-    async updateDidTx(signInputs: ISignInputs[], 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 value: MsgUpdateDid = {
-            payload,
-            signatures
-        }
-
-        const updateDidMsg: MsgUpdateDidEncodeObject = {
-            typeUrl: typeUrlMsgUpdateDid,
-            value
-        }
-
-        return this._signer.signAndBroadcast(
-            address,
-            [updateDidMsg],
-            fee,
-            memo
-        )
+export interface MsgUpdateDidResponseEncodeObject extends EncodeObject {
+	readonly typeUrl: typeof typeUrlMsgUpdateDidResponse,
+	readonly value: Partial<MsgUpdateDidResponse>
+}
+
+export function MsgUpdateDidResponseEncodeObject(obj: EncodeObject): obj is MsgUpdateDidResponseEncodeObject {
+	return obj.typeUrl === typeUrlMsgUpdateDidResponse
+}
+
+export class DIDModule extends AbstractCheqdSDKModule {
+	static readonly registryTypes: Iterable<[string, GeneratedType]> = [
+        [typeUrlMsgCreateDid, MsgCreateDid],
+        [typeUrlMsgCreateDidResponse, MsgCreateDidResponse],
+        [typeUrlMsgUpdateDid, MsgUpdateDid],
+        [typeUrlMsgUpdateDidResponse, MsgUpdateDidResponse],
+    ]
+
+	constructor(signer: CheqdSigningStargateClient) {
+		super(signer)
+		this.methods = {
+			createDidTx: this.createDidTx.bind(this),
+			updateDidTx: this.updateDidTx.bind(this)
+		}
+	}
+
+    public getRegistryTypes(): Iterable<[string, GeneratedType]> {
+        return DIDModule.registryTypes
     }
+
+	async createDidTx(signInputs: ISignInputs[], 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 value: MsgCreateDid = {
+			payload,
+			signatures
+		}
+
+		const createDidMsg: MsgCreateDidEncodeObject = {
+			typeUrl: typeUrlMsgCreateDid,
+			value
+		}
+
+		return this._signer.signAndBroadcast(
+			address,
+			[createDidMsg],
+			fee,
+			memo
+		)
+	}
+
+	async updateDidTx(signInputs: ISignInputs[], 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 value: MsgUpdateDid = {
+			payload,
+			signatures
+		}
+
+		const updateDidMsg: MsgUpdateDidEncodeObject = {
+			typeUrl: typeUrlMsgUpdateDid,
+			value
+		}
+
+		return this._signer.signAndBroadcast(
+			address,
+			[updateDidMsg],
+			fee,
+			memo
+		)
+	}
 }
 
 export type MinimalImportableDIDModule = MinimalImportableCheqdSDKModule<DIDModule>
 
 export interface DidExtension extends CheqdExtension<string, {}> {
-    did: {}
+	did: {}
 }
 
 export const setupDidExtension = (base: QueryClient): DidExtension => {
-    const rpc = createProtobufRpcClient(base)
+	const rpc = createProtobufRpcClient(base)
 
-    /* const queryService = new QueryClientImpl(rpc) */
+	/* const queryService = new QueryClientImpl(rpc) */
 
-    return {
-        did: {
-            //...
-        }
-    }
-}
+	return {
+		did: {
+			//...
+		}
+	}
+}

package/src/modules/resources.ts

@@ -1,11 +1,18 @@
 import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
 import { CheqdSigningStargateClient } from "../signer"
+import { GeneratedType } from "@cosmjs/proto-signing"
 
 
 export class ResourcesModule extends AbstractCheqdSDKModule {
-    constructor(signer: CheqdSigningStargateClient) {
-        super(signer)
-    }
+	registryTypes: Iterable<[string, GeneratedType]> = []
+
+	constructor(signer: CheqdSigningStargateClient) {
+		super(signer)
+	}
+
+	public getRegistryTypes(): Iterable<[string, GeneratedType]> {
+		return []
+	}
 }
 
-export type MinimalImportableResourcesModule = MinimalImportableCheqdSDKModule<ResourcesModule>
+export type MinimalImportableResourcesModule = MinimalImportableCheqdSDKModule<ResourcesModule>

package/src/registry.ts

@@ -1,71 +1,15 @@
 import {
-    Registry,
-    GeneratedType,
-    EncodeObject
+	Registry,
+	GeneratedType,
 } from '@cosmjs/proto-signing'
 
 import {
-    defaultRegistryTypes
+	defaultRegistryTypes
 } from '@cosmjs/stargate'
 
-import {
-    MsgCreateDid, MsgCreateDidResponse, MsgUpdateDid, MsgUpdateDidResponse
-} from '@cheqd/ts-proto/cheqd/v1/tx'
-
-export const typeUrlMsgCreateDid = '/cheqdid.cheqdnode.cheqd.v1.MsgCreateDid'
-export const typeUrlMsgCreateDidResponse = '/cheqdid.cheqdnode.cheqd.v1.MsgCreateDidResponse'
-export const typeUrlMsgUpdateDid = '/cheqdid.cheqdnode.cheqd.v1.MsgUpdateDid'
-export const typeUrlMsgUpdateDidResponse = '/cheqdid.cheqdnode.cheqd.v1.MsgUpdateDidResponse'
-
-const defaultCheqdRegistryTypes: Iterable<[string, GeneratedType]> = [
-    ...defaultRegistryTypes,
-
-    /** Move them as registrations to each module's constructor. */
-
-    [typeUrlMsgCreateDid, MsgCreateDid],
-    [typeUrlMsgCreateDidResponse, MsgCreateDidResponse],
-    [typeUrlMsgUpdateDid, MsgUpdateDid],
-    [typeUrlMsgUpdateDidResponse, MsgUpdateDidResponse],
-]
-
-export function createDefaultCheqdRegistry(): Registry {
-    return new Registry(defaultCheqdRegistryTypes)
-}
-
-export const CheqdRegistry = new Registry(defaultCheqdRegistryTypes)
-
-export interface MsgCreateDidEncodeObject extends EncodeObject {
-    readonly typeUrl: typeof typeUrlMsgCreateDid,
-    readonly value: Partial<MsgCreateDid>
-}
-
-export function isMsgCreateDidEncodeObject(obj: EncodeObject): obj is MsgCreateDidEncodeObject {
-    return obj.typeUrl === typeUrlMsgCreateDid
-}
-
-export interface MsgCreateDidResponseEncodeObject extends EncodeObject {
-    readonly typeUrl: typeof typeUrlMsgCreateDidResponse,
-    readonly value: Partial<MsgCreateDidResponse>
-}
-
-export function MsgCreateDidResponseEncodeObject(obj: EncodeObject): obj is MsgCreateDidResponseEncodeObject {
-    return obj.typeUrl === typeUrlMsgCreateDidResponse
-}
-
-export interface MsgUpdateDidEncodeObject extends EncodeObject {
-    readonly typeUrl: typeof typeUrlMsgUpdateDid,
-    readonly value: Partial<MsgUpdateDid>
-}
-
-export function MsgUpdateDidEncodeObject(obj: EncodeObject): obj is MsgUpdateDidEncodeObject {
-    return obj.typeUrl === typeUrlMsgUpdateDid
-}
-
-export interface MsgUpdateDidResponseEncodeObject extends EncodeObject {
-    readonly typeUrl: typeof typeUrlMsgUpdateDidResponse,
-    readonly value: Partial<MsgUpdateDidResponse>
+export function createDefaultCheqdRegistry(customTypes?: Iterable<[string, GeneratedType]>): Registry {
+	if (!customTypes) customTypes = [];
+	return new Registry([...defaultRegistryTypes, ...customTypes])
 }
 
-export function MsgUpdateDidResponseEncodeObject(obj: EncodeObject): obj is MsgUpdateDidResponseEncodeObject {
-    return obj.typeUrl === typeUrlMsgUpdateDidResponse
-}
+export const CheqdRegistry = new Registry(defaultRegistryTypes)

package/src/signer.ts

@@ -1,5 +1,5 @@
 import { CheqdExtensions } from './modules/_'
-import { EncodeObject, isOfflineDirectSigner, OfflineSigner, encodePubkey, TxBodyEncodeObject, makeSignDoc } from "@cosmjs/proto-signing"
+import { EncodeObject, isOfflineDirectSigner, OfflineSigner, encodePubkey, TxBodyEncodeObject, makeSignDoc, Registry } from "@cosmjs/proto-signing"
 import { DeliverTxResponse, GasPrice, HttpEndpoint, QueryClient, SigningStargateClient, SigningStargateClientOptions, calculateFee, SignerData } from "@cosmjs/stargate"
 import { Tendermint34Client } from "@cosmjs/tendermint-rpc"
 import { createDefaultCheqdRegistry } from "./registry"
@@ -19,211 +19,210 @@ import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin'
 import Long from 'long'
 
 export function calculateDidFee(gasLimit: number, gasPrice: string | GasPrice): DidStdFee {
-    return calculateFee(gasLimit, gasPrice)
+	return calculateFee(gasLimit, gasPrice)
 }
 
 export function makeSignerInfos(
-    signers: ReadonlyArray<{ readonly pubkey: Any; readonly sequence: number }>,
-    signMode: SignMode,
+	signers: ReadonlyArray<{ readonly pubkey: Any; readonly sequence: number }>,
+	signMode: SignMode,
 ): SignerInfo[] {
-    return signers.map(
-        ({ pubkey, sequence }): SignerInfo => ({
-            publicKey: pubkey,
-            modeInfo: {
-                single: { mode: signMode },
-            },
-            sequence: Long.fromNumber(sequence),
-        }),
-    );
+	return signers.map(
+		({ pubkey, sequence }): SignerInfo => ({
+			publicKey: pubkey,
+			modeInfo: {
+				single: { mode: signMode },
+			},
+			sequence: Long.fromNumber(sequence),
+		}),
+	);
 }
 
 export function makeDidAuthInfoBytes(
-    signers: ReadonlyArray<{ readonly pubkey: Any; readonly sequence: number }>,
-    feeAmount: readonly Coin[],
-    gasLimit: number,
-    feePayer: string,
-    signMode = SignMode.SIGN_MODE_DIRECT,
+	signers: ReadonlyArray<{ readonly pubkey: Any; readonly sequence: number }>,
+	feeAmount: readonly Coin[],
+	gasLimit: number,
+	feePayer: string,
+	signMode = SignMode.SIGN_MODE_DIRECT,
 ): Uint8Array {
-    const authInfo = {
-        signerInfos: makeSignerInfos(signers, signMode),
-        fee: {
-            amount: [...feeAmount],
-            gasLimit: Long.fromNumber(gasLimit),
-            payer: feePayer
-        }
-    }
-    return AuthInfo.encode(AuthInfo.fromPartial(authInfo)).finish()
+	const authInfo = {
+		signerInfos: makeSignerInfos(signers, signMode),
+		fee: {
+			amount: [...feeAmount],
+			gasLimit: Long.fromNumber(gasLimit),
+			payer: feePayer
+		}
+	}
+	return AuthInfo.encode(AuthInfo.fromPartial(authInfo)).finish()
 }
 
 
 export class CheqdSigningStargateClient extends SigningStargateClient {
-    public readonly cheqdExtensions: CheqdExtensions | undefined
-    private didSigners: TSignerAlgo = {}
-    private readonly _gasPrice: GasPrice | undefined
-    private readonly _signer: OfflineSigner
-
-    public static async connectWithSigner(endpoint: string | HttpEndpoint, signer: OfflineSigner, options?: SigningStargateClientOptions | undefined): Promise<CheqdSigningStargateClient> {
-        const tmClient = await Tendermint34Client.connect(endpoint)
-        return new CheqdSigningStargateClient(tmClient, signer, {
-            registry: createDefaultCheqdRegistry(),
-            ...options
-        })
-    }
-
-    constructor(
-        tmClient: Tendermint34Client | undefined,
-        signer: OfflineSigner,
-        options: SigningStargateClientOptions = {}
-    ) {
-        super(tmClient, signer, options)
-        this._signer = signer
-        if (options.gasPrice) this._gasPrice = options.gasPrice
-
-        /** GRPC Connection */
-
-        /* if (tmClient) {
-            this.cheqdExtensions = QueryClient.withExtensions(tmClient, setupCheqdExtensions)
-        } */
-    }
-
-    async signAndBroadcast(
-        signerAddress: string,
-        messages: readonly EncodeObject[],
-        fee: DidStdFee | "auto" | number,
-        memo = "",
-    ): Promise<DeliverTxResponse> {
-        let usedFee: DidStdFee
-        if (fee == "auto" || typeof fee === "number") {
-            assertDefined(this._gasPrice, "Gas price must be set in the client options when auto gas is used.")
-            const gasEstimation = await this.simulate(signerAddress, messages, memo)
-            const multiplier = typeof fee === "number" ? fee : 1.3
-            usedFee = calculateDidFee(Math.round(gasEstimation * multiplier), this._gasPrice)
-            usedFee.payer = signerAddress
-        } else {
-            usedFee = fee
-            assertDefined(usedFee.payer, "Payer address must be set when fee is not auto.")
-            signerAddress = usedFee.payer!
-        }
-        const txRaw = await this.sign(signerAddress, messages, usedFee, memo)
-        const txBytes = TxRaw.encode(txRaw).finish()
-        return this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs)
-    }
-
-    public async sign(
-        signerAddress: string,
-        messages: readonly EncodeObject[],
-        fee: DidStdFee,
-        memo: string,
-        explicitSignerData?: SignerData,
-    ): Promise<TxRaw> {
-        let signerData: SignerData
-        if (explicitSignerData) {
-            signerData = explicitSignerData
-        } else {
-            const { accountNumber, sequence } = await this.getSequence(signerAddress)
-            const chainId = await this.getChainId()
-            signerData = {
-                accountNumber: accountNumber,
-                sequence: sequence,
-                chainId: chainId,
-            }
-        }
-    
-        return this._signDirect(signerAddress, messages, fee, memo, signerData)
-
-        // TODO: override signAmino as well
-        /* return isOfflineDirectSigner(this._signer)
-            ? this._signDirect(signerAddress, messages, fee, memo, signerData)
-            : this._signAmino(signerAddress, messages, fee, memo, signerData) */
-    }
-
-    private async _signDirect(
-        signerAddress: string,
-        messages: readonly EncodeObject[],
-        fee: DidStdFee,
-        memo: string,
-        { accountNumber, sequence, chainId }: SignerData,
-    ): Promise<TxRaw> {
-        assert(isOfflineDirectSigner(this._signer))
-        const accountFromSigner = (await this._signer.getAccounts()).find(
-            (account) => account.address === signerAddress,
-        )
-        if (!accountFromSigner) {
-            throw new Error("Failed to retrieve account from signer")
-        }
-        const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey))
-        const txBodyEncodeObject: TxBodyEncodeObject = {
-            typeUrl: "/cosmos.tx.v1beta1.TxBody",
-            value: {
-                messages: messages,
-                memo: memo,
-            },
-        }
-        const txBodyBytes = this.registry.encode(txBodyEncodeObject)
-        const gasLimit = Int53.fromString(fee.gas).toNumber()
-        const authInfoBytes = makeDidAuthInfoBytes([{ pubkey, sequence }], fee.amount, gasLimit, fee.payer!)
-        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber)
-        const { signature, signed } = await this._signer.signDirect(signerAddress, signDoc)
-        return TxRaw.fromPartial({
-            bodyBytes: signed.bodyBytes,
-            authInfoBytes: signed.authInfoBytes,
-            signatures: [fromBase64(signature.signature)],
-        })
-    }
-
-    async checkDidSigners(verificationMethods: Partial<VerificationMethod>[] = []): Promise<TSignerAlgo> {
-        if (verificationMethods.length === 0) {
-            throw new Error('No verification methods provided')
-        }
-
-        verificationMethods.forEach((verificationMethod) => {
-            if (!(Object.values(VerificationMethods) as string[]).includes(verificationMethod.type ?? '')) {
-                throw new Error(`Unsupported verification method type: ${verificationMethod.type}`)
-            }
-            if (!this.didSigners[verificationMethod.type ?? '']) {
-                this.didSigners[verificationMethod.type ?? ''] = EdDSASigner
-            }
-        })
-
-        return this.didSigners
-    }
-
-    async getDidSigner(verificationMethodId: string, verificationMethods: Partial<VerificationMethod>[]): Promise<(secretKey: Uint8Array) => Signer> {
-        await this.checkDidSigners(verificationMethods)
-        const verificationMethod = verificationMethods.find(method => method.id === verificationMethodId)?.type
-        if (!verificationMethod) {
-            throw new Error(`Verification method for ${verificationMethodId} not found`)
-        }
-        return this.didSigners[verificationMethod]!
-    }
-
-    async signCreateDidTx(signInputs: ISignInputs[], payload: MsgCreateDidPayload): Promise<SignInfo[]> {
-        await this.checkDidSigners(payload?.verificationMethod)
-
-        const signBytes = MsgCreateDidPayload.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')
-            }
-        }))
-
-        return signInfos
-    }
-
-    async signUpdateDidTx(signInputs: ISignInputs[], payload: MsgUpdateDidPayload): Promise<SignInfo[]> {
-        await this.checkDidSigners(payload?.verificationMethod)
-
-        const signBytes = MsgUpdateDidPayload.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')
-            }
-        }))
-
-        return signInfos
-    }
-}
+	public readonly cheqdExtensions: CheqdExtensions | undefined
+	private didSigners: TSignerAlgo = {}
+	private readonly _gasPrice: GasPrice | undefined
+	private readonly _signer: OfflineSigner
+
+	public static async connectWithSigner(endpoint: string | HttpEndpoint, signer: OfflineSigner, options?: SigningStargateClientOptions | undefined): Promise<CheqdSigningStargateClient> {
+		const tmClient = await Tendermint34Client.connect(endpoint)
+		return new CheqdSigningStargateClient(tmClient, signer, {
+			registry: options?.registry ? options.registry : createDefaultCheqdRegistry(),
+			...options
+		})
+	}
+
+	constructor(
+		tmClient: Tendermint34Client | undefined,
+		signer: OfflineSigner,
+		options: SigningStargateClientOptions = {}
+	) {
+		super(tmClient, signer, options)
+		this._signer = signer
+		if (options.gasPrice) this._gasPrice = options.gasPrice
+		/** GRPC Connection */
+
+		/* if (tmClient) {
+			this.cheqdExtensions = QueryClient.withExtensions(tmClient, setupCheqdExtensions)
+		} */
+	}
+
+	async signAndBroadcast(
+		signerAddress: string,
+		messages: readonly EncodeObject[],
+		fee: DidStdFee | "auto" | number,
+		memo = "",
+	): Promise<DeliverTxResponse> {
+		let usedFee: DidStdFee
+		if (fee == "auto" || typeof fee === "number") {
+			assertDefined(this._gasPrice, "Gas price must be set in the client options when auto gas is used.")
+			const gasEstimation = await this.simulate(signerAddress, messages, memo)
+			const multiplier = typeof fee === "number" ? fee : 1.3
+			usedFee = calculateDidFee(Math.round(gasEstimation * multiplier), this._gasPrice)
+			usedFee.payer = signerAddress
+		} else {
+			usedFee = fee
+			assertDefined(usedFee.payer, "Payer address must be set when fee is not auto.")
+			signerAddress = usedFee.payer!
+		}
+		const txRaw = await this.sign(signerAddress, messages, usedFee, memo)
+		const txBytes = TxRaw.encode(txRaw).finish()
+		return this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs)
+	}
+
+	public async sign(
+		signerAddress: string,
+		messages: readonly EncodeObject[],
+		fee: DidStdFee,
+		memo: string,
+		explicitSignerData?: SignerData,
+	): Promise<TxRaw> {
+		let signerData: SignerData
+		if (explicitSignerData) {
+			signerData = explicitSignerData
+		} else {
+			const { accountNumber, sequence } = await this.getSequence(signerAddress)
+			const chainId = await this.getChainId()
+			signerData = {
+				accountNumber: accountNumber,
+				sequence: sequence,
+				chainId: chainId,
+			}
+		}
+
+		return this._signDirect(signerAddress, messages, fee, memo, signerData)
+
+		// TODO: override signAmino as well
+		/* return isOfflineDirectSigner(this._signer)
+			? this._signDirect(signerAddress, messages, fee, memo, signerData)
+			: this._signAmino(signerAddress, messages, fee, memo, signerData) */
+	}
+
+	private async _signDirect(
+		signerAddress: string,
+		messages: readonly EncodeObject[],
+		fee: DidStdFee,
+		memo: string,
+		{ accountNumber, sequence, chainId }: SignerData,
+	): Promise<TxRaw> {
+		assert(isOfflineDirectSigner(this._signer))
+		const accountFromSigner = (await this._signer.getAccounts()).find(
+			(account) => account.address === signerAddress,
+		)
+		if (!accountFromSigner) {
+			throw new Error("Failed to retrieve account from signer")
+		}
+		const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey))
+		const txBodyEncodeObject: TxBodyEncodeObject = {
+			typeUrl: "/cosmos.tx.v1beta1.TxBody",
+			value: {
+				messages: messages,
+				memo: memo,
+			},
+		}
+		const txBodyBytes = this.registry.encode(txBodyEncodeObject)
+		const gasLimit = Int53.fromString(fee.gas).toNumber()
+		const authInfoBytes = makeDidAuthInfoBytes([{ pubkey, sequence }], fee.amount, gasLimit, fee.payer!)
+		const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber)
+		const { signature, signed } = await this._signer.signDirect(signerAddress, signDoc)
+		return TxRaw.fromPartial({
+			bodyBytes: signed.bodyBytes,
+			authInfoBytes: signed.authInfoBytes,
+			signatures: [fromBase64(signature.signature)],
+		})
+	}
+
+	async checkDidSigners(verificationMethods: Partial<VerificationMethod>[] = []): Promise<TSignerAlgo> {
+		if (verificationMethods.length === 0) {
+			throw new Error('No verification methods provided')
+		}
+
+		verificationMethods.forEach((verificationMethod) => {
+			if (!(Object.values(VerificationMethods) as string[]).includes(verificationMethod.type ?? '')) {
+				throw new Error(`Unsupported verification method type: ${verificationMethod.type}`)
+			}
+			if (!this.didSigners[verificationMethod.type ?? '']) {
+				this.didSigners[verificationMethod.type ?? ''] = EdDSASigner
+			}
+		})
+
+		return this.didSigners
+	}
+
+	async getDidSigner(verificationMethodId: string, verificationMethods: Partial<VerificationMethod>[]): Promise<(secretKey: Uint8Array) => Signer> {
+		await this.checkDidSigners(verificationMethods)
+		const verificationMethod = verificationMethods.find(method => method.id === verificationMethodId)?.type
+		if (!verificationMethod) {
+			throw new Error(`Verification method for ${verificationMethodId} not found`)
+		}
+		return this.didSigners[verificationMethod]!
+	}
+
+	async signCreateDidTx(signInputs: ISignInputs[], payload: MsgCreateDidPayload): Promise<SignInfo[]> {
+		await this.checkDidSigners(payload?.verificationMethod)
+
+		const signBytes = MsgCreateDidPayload.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')
+			}
+		}))
+
+		return signInfos
+	}
+
+	async signUpdateDidTx(signInputs: ISignInputs[], payload: MsgUpdateDidPayload): Promise<SignInfo[]> {
+		await this.checkDidSigners(payload?.verificationMethod)
+
+		const signBytes = MsgUpdateDidPayload.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')
+			}
+		}))
+
+		return signInfos
+	}
+}

package/tests/index.test.ts

@@ -1,8 +1,9 @@
-import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing'
+import { DirectSecp256k1HdWallet, GeneratedType } from '@cosmjs/proto-signing'
 import { createCheqdSDK, DIDModule, ICheqdSDKOptions } from '../src/index'
 import { exampleCheqdNetwork, faucet } from './testutils.test'
 import { AbstractCheqdSDKModule } from '../src/modules/_'
 import { CheqdSigningStargateClient } from '../src/signer'
+import { createDefaultCheqdRegistry } from '../src/registry'
 
 describe(
     'CheqdSDK', () => {
@@ -27,15 +28,18 @@ describe(
             it('should use module methods', async () => {
                 const rpcUrl = exampleCheqdNetwork.rpcUrl
                 const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-                const testSigner = await CheqdSigningStargateClient.connectWithSigner(rpcUrl, wallet)
 
                 class TestModule extends AbstractCheqdSDKModule {
+                    registryTypes: Iterable<[string, GeneratedType]> = []
                     methods = {
                         doSomething: this.doSomething.bind(this)
                     }
                     constructor(signer: CheqdSigningStargateClient) {
                         super(signer)
                     }
+                    public getRegistryTypes(): Iterable<[string, GeneratedType]> {
+                        return TestModule.registryTypes
+                    }
                     async doSomething(): Promise<string> {
                         return 'did something'
                     }
@@ -58,6 +62,20 @@ describe(
                 await cheqdSDK.doSomething()
                 expect(spy).toHaveBeenCalled()
             })
+
+            it('should instantiate registry from passed modules', async () => {
+                const options = {
+                    modules: [DIDModule as unknown as AbstractCheqdSDKModule],
+                    rpcUrl: exampleCheqdNetwork.rpcUrl,
+                    wallet: await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
+                } as ICheqdSDKOptions
+                const cheqdSDK = await createCheqdSDK(options)
+
+                const didRegistryTypes = DIDModule.registryTypes
+                const cheqdRegistry = createDefaultCheqdRegistry(didRegistryTypes)
+
+                expect(cheqdSDK.signer.registry).toStrictEqual(cheqdRegistry)
+            })
         })
     }
 )

package/tests/modules/did.test.ts

@@ -3,11 +3,13 @@ import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"
 import { DeliverTxResponse } from "@cosmjs/stargate"
 import { fromString, toString } from 'uint8arrays'
 import { DIDModule } from "../../src"
+import { AbstractCheqdSDKModule } from "../../src/modules/_"
+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"
 
-const defaultAsyncTxTimeout = 10000
+const defaultAsyncTxTimeout = 20000
 
 describe('DIDModule', () => {
     describe('constructor', () => {
@@ -22,7 +24,8 @@ describe('DIDModule', () => {
     describe('createDidTx', () => {
         it('should create a new multibase DID', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            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)
@@ -59,7 +62,8 @@ describe('DIDModule', () => {
 
         it('should create a new uuid DID', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            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.Uuid, 'key-1', 16)
@@ -98,7 +102,8 @@ describe('DIDModule', () => {
     describe('updateDidTx', () => {
         it('should update a DID', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const registry = createDefaultCheqdRegistry(DIDModule.registryTypes)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet, { registry })
             const didModule = new DIDModule(signer)
             
             const keyPair = createKeyPairBase64()

package/tests/signer.test.ts

@@ -2,7 +2,7 @@ import { VerificationMethod } from "@cheqd/ts-proto/cheqd/v1/did"
 import { MsgCreateDid, MsgCreateDidPayload, SignInfo } from "@cheqd/ts-proto/cheqd/v1/tx"
 import { DirectSecp256k1HdWallet, Registry } from "@cosmjs/proto-signing"
 import { base64ToBytes, EdDSASigner } from "did-jwt"
-import { typeUrlMsgCreateDid } from "../src/registry"
+import { typeUrlMsgCreateDid } from '../src/modules/did'
 import { CheqdSigningStargateClient } from "../src/signer"
 import { ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from "../src/types"
 import { fromString, toString } from 'uint8arrays'