@cheqd/sdk 2.0.2-develop.1 → 2.1.0

package/src/modules/did.ts

@@ -1,25 +1,42 @@
-import { createProtobufRpcClient, DeliverTxResponse, QueryClient } from "@cosmjs/stargate"
-/* import { QueryClientImpl } from '@cheqd/ts-proto/cheqd/did/v1/query' */
-import { CheqdExtension, AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
+import { createPagination, createProtobufRpcClient, DeliverTxResponse, QueryClient } from "@cosmjs/stargate"
+import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from './_';
 import { CheqdSigningStargateClient } from "../signer"
-import { DIDDocument, DidStdFee, IContext, ISignInputs, SpecValidationResult, VerificationMethods } from '../types';
+import { DIDDocument, DidStdFee, IContext, ISignInputs, QueryExtensionSetup, SpecValidationResult, VerificationMethods, DIDDocumentWithMetadata } from '../types';
 import { 
-	MsgCreateDidDoc, 
-	MsgCreateDidDocPayload, 
-	MsgCreateDidDocResponse, 
-	MsgDeactivateDidDoc, 
-	MsgDeactivateDidDocPayload, 
-	MsgDeactivateDidDocResponse, 
-	MsgUpdateDidDoc, 
-	MsgUpdateDidDocPayload, 
-	MsgUpdateDidDocResponse, 
-	protobufPackage, 
-	Service, 
+	MsgCreateDidDoc,
+	MsgCreateDidDocPayload,
+	MsgCreateDidDocResponse,
+	MsgDeactivateDidDoc,
+	MsgDeactivateDidDocPayload,
+	MsgDeactivateDidDocResponse,
+	MsgUpdateDidDoc,
+	MsgUpdateDidDocPayload,
+	MsgUpdateDidDocResponse,
+	protobufPackage,
+	QueryClientImpl,
+	Service,
 	SignInfo,
-	VerificationMethod
+	VerificationMethod,
+	QueryAllDidDocVersionsMetadataResponse,
+	DidDocWithMetadata,
+	DidDoc,
+	Metadata
 } from "@cheqd/ts-proto/cheqd/did/v2"
 import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing"
 import { v4 } from "uuid"
+import { assert } from "@cosmjs/utils";
+import { PageRequest } from "@cheqd/ts-proto/cosmos/base/query/v1beta1/pagination";
+import { CheqdQuerier } from "../querier";
+import { DIDDocumentMetadata } from "did-resolver";
+
+export const defaultDidExtensionKey = "did" as const
+
+export const contexts = {
+	W3CDIDv1: "https://www.w3.org/ns/did/v1",
+	W3CSuiteEd255192020: "https://w3id.org/security/suites/ed25519-2020/v1",
+	W3CSuiteEd255192018: "https://w3id.org/security/suites/ed25519-2018/v1",
+	W3CSuiteJws2020: "https://w3id.org/security/suites/jws-2020/v1",
+} as const
 
 export const protobufLiterals = {
 	MsgCreateDidDoc: "MsgCreateDidDoc",
@@ -90,6 +107,42 @@ export function MsgDeactiveDidDocResponseEncodeObject(obj: EncodeObject): obj is
 	return obj.typeUrl === typeUrlMsgUpdateDidDocResponse
 }
 
+
+export type MinimalImportableDIDModule = MinimalImportableCheqdSDKModule<DIDModule>
+
+export type DidExtension = {
+	readonly [defaultDidExtensionKey]: {
+		readonly didDoc: (id: string) => Promise<DidDocWithMetadata>
+		readonly didDocVersion: (id: string, versionId: string) => Promise<DidDocWithMetadata>
+		readonly allDidDocVersionsMetadata: (id: string, paginationKey?: Uint8Array) => Promise<QueryAllDidDocVersionsMetadataResponse>
+	}
+}
+
+export const setupDidExtension = (base: QueryClient): DidExtension => {
+	const rpc = createProtobufRpcClient(base)
+
+	const queryService = new QueryClientImpl(rpc)
+
+	return {
+		[defaultDidExtensionKey]: {
+			didDoc: async (id: string) => {
+				const { value } = await queryService.DidDoc({ id })
+				assert(value)
+				return value
+			},
+			didDocVersion: async (id: string, versionId: string) => {
+				const { value } = await queryService.DidDocVersion({ id, version: versionId })
+				assert(value)
+				return value
+			},
+			allDidDocVersionsMetadata: async (id: string, paginationKey?: Uint8Array) => {
+				const response = await queryService.AllDidDocVersionsMetadata({ id, pagination: createPagination(paginationKey) as PageRequest | undefined })
+				return response
+			}
+		}
+	} as DidExtension
+}
+
 export class DIDModule extends AbstractCheqdSDKModule {
 	static readonly registryTypes: Iterable<[string, GeneratedType]> = [
         [typeUrlMsgCreateDidDoc, MsgCreateDidDoc],
@@ -103,17 +156,25 @@ export class DIDModule extends AbstractCheqdSDKModule {
 	static readonly baseMinimalDenom = 'ncheq' as const
 
 	static readonly fees = {
-		DefaultCreateDidFee: { amount: '50000000000', denom: DIDModule.baseMinimalDenom } as const,
-		DefaultUpdateDidFee: { amount: '25000000000', denom: DIDModule.baseMinimalDenom } as const,
-		DefaultDeactivateDidFee: { amount: '10000000000', denom: DIDModule.baseMinimalDenom } as const,
+		DefaultCreateDidDocFee: { amount: '50000000000', denom: DIDModule.baseMinimalDenom } as const,
+		DefaultUpdateDidDocFee: { amount: '25000000000', denom: DIDModule.baseMinimalDenom } as const,
+		DefaultDeactivateDidDocFee: { amount: '10000000000', denom: DIDModule.baseMinimalDenom } as const,
 	} as const
 
-	constructor(signer: CheqdSigningStargateClient) {
-		super(signer)
+	static readonly querierExtensionSetup: QueryExtensionSetup<DidExtension> = setupDidExtension
+
+	readonly querier: CheqdQuerier & DidExtension
+
+	constructor(signer: CheqdSigningStargateClient, querier: CheqdQuerier & DidExtension) {
+		super(signer, querier)
+		this.querier = querier
 		this.methods = {
-			createDidTx: this.createDidTx.bind(this),
-			updateDidTx: this.updateDidTx.bind(this),
-			deactivateDidTx: this.deactivateDidTx.bind(this),
+			createDidDocTx: this.createDidDocTx.bind(this),
+			updateDidDocTx: this.updateDidDocTx.bind(this),
+			deactivateDidDocTx: this.deactivateDidDocTx.bind(this),
+			queryDidDoc: this.querier.did.didDoc.bind(this),
+			queryDidDocVersion: this.querier.did.didDocVersion.bind(this),
+			queryAllDidDocVersionsMetadata: this.querier.did.allDidDocVersionsMetadata.bind(this),
 		}
 	}
 
@@ -121,7 +182,11 @@ export class DIDModule extends AbstractCheqdSDKModule {
         return DIDModule.registryTypes
     }
 
-	async createDidTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
+	public getQuerierExtensionSetup(): QueryExtensionSetup<DidExtension> {
+		return DIDModule.querierExtensionSetup
+	}
+
+	async createDidDocTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}
@@ -153,7 +218,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 
 		let signatures: SignInfo[]
 		if(ISignInputs.isSignInput(signInputs)) {
-			signatures = await this._signer.signCreateDidTx(signInputs, payload)
+			signatures = await this._signer.signcreateDidDocTx(signInputs, payload)
 		} else {
 			signatures = signInputs
 		}
@@ -184,7 +249,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		)
 	}
 
-	async updateDidTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async updateDidDocTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}
@@ -215,7 +280,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		})
 		let signatures: SignInfo[]
 		if(ISignInputs.isSignInput(signInputs)) {
-			signatures = await this._signer.signUpdateDidTx(signInputs, payload)
+			signatures = await this._signer.signupdateDidDocTx(signInputs, payload)
 		} else {
 			signatures = signInputs
 		}
@@ -246,7 +311,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		)
 	}
 
-	async deactivateDidTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async deactivateDidDocTx(signInputs: ISignInputs[] | SignInfo[], didPayload: DIDDocument, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, versionId?: string, context?: IContext): Promise<DeliverTxResponse> {
 		if (!this._signer) {
 			this._signer = context!.sdk!.signer
 		}
@@ -268,7 +333,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 
 		let signatures: SignInfo[]
 		if(ISignInputs.isSignInput(signInputs)) {
-			signatures = await this._signer.signDeactivateDidTx(signInputs, payload, protobufVerificationMethod!)
+			signatures = await this._signer.signdeactivateDidDocTx(signInputs, payload, protobufVerificationMethod!)
 		} else {
 			signatures = signInputs
 		}
@@ -299,6 +364,30 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		)
 	}
 
+	async queryDidDoc(id: string, context?: IContext): Promise<DIDDocumentWithMetadata> {
+		const { didDoc, metadata } = await this.querier[defaultDidExtensionKey].didDoc(id)
+		return {
+			didDocument: await DIDModule.toSpecCompliantPayload(didDoc!),
+			didDocumentMetadata: await DIDModule.toSpecCompliantMetadata(metadata!)
+		} as DIDDocumentWithMetadata
+	}
+
+	async queryDidDocVersion(id: string, versionId: string, context?: IContext): Promise<DIDDocumentWithMetadata> {
+		const { didDoc, metadata } = await this.querier[defaultDidExtensionKey].didDocVersion(id, versionId)
+		return {
+			didDocument: await DIDModule.toSpecCompliantPayload(didDoc!),
+			didDocumentMetadata: await DIDModule.toSpecCompliantMetadata(metadata!)
+		} as DIDDocumentWithMetadata
+	}
+
+	async queryAllDidDocVersionsMetadata(id: string, context?: IContext): Promise<{ didDocumentVersionsMetadata: DIDDocumentMetadata[], pagination: QueryAllDidDocVersionsMetadataResponse['pagination']}> {
+		const { versions, pagination } = await this.querier[defaultDidExtensionKey].allDidDocVersionsMetadata(id)
+		return {
+			didDocumentVersionsMetadata: await Promise.all(versions.map(async (m) => await DIDModule.toSpecCompliantMetadata(m))),
+			pagination
+		}
+	}
+
 	static async validateSpecCompliantPayload(didDocument: DIDDocument): Promise<SpecValidationResult> {
 		// id is required, validated on both compile and runtime
 		if (!didDocument?.id) return { valid: false, error: 'id is required' }
@@ -355,10 +444,95 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		return { valid: true, protobufVerificationMethod: protoVerificationMethod, protobufService: protoService } as SpecValidationResult
 	}
 
+	static async toSpecCompliantPayload(protobufDidDocument: DidDoc): Promise<DIDDocument> {
+		const verificationMethod = protobufDidDocument.verificationMethod.map((vm) => {
+			switch (vm.verificationMethodType) {
+				case VerificationMethods.Ed255192020:
+					if (!protobufDidDocument.context.includes(contexts.W3CSuiteEd255192020)) 
+						protobufDidDocument.context = [...protobufDidDocument.context, contexts.W3CSuiteEd255192020]
+					return {
+						id: vm.id,
+						type: vm.verificationMethodType,
+						controller: vm.controller,
+						publicKeyMultibase: vm.verificationMaterial,
+					}
+				case VerificationMethods.JWK:
+					if (!protobufDidDocument.context.includes(contexts.W3CSuiteJws2020)) 
+						protobufDidDocument.context = [...protobufDidDocument.context, contexts.W3CSuiteJws2020]
+					return {
+						id: vm.id,
+						type: vm.verificationMethodType,
+						controller: vm.controller,
+						publicKeyJwk: JSON.parse(vm.verificationMaterial),
+					}
+				case VerificationMethods.Ed255192018:
+					if (!protobufDidDocument.context.includes(contexts.W3CSuiteEd255192018))
+						protobufDidDocument.context = [...protobufDidDocument.context, contexts.W3CSuiteEd255192018]
+					return {
+						id: vm.id,
+						type: vm.verificationMethodType,
+						controller: vm.controller,
+						publicKeyBase58: vm.verificationMaterial,
+					}
+				default:
+					throw new Error('Unsupported verificationMethod type') // should never happen
+			}
+		})
+
+		const service = protobufDidDocument.service.map((s) => {
+			return {
+				id: s.id,
+				type: s.serviceType,
+				serviceEndpoint: s.serviceEndpoint,
+			}
+		})
+
+		const context = function () {
+			if (protobufDidDocument.context.includes(contexts.W3CDIDv1))
+				return protobufDidDocument.context
+
+			return [contexts.W3CDIDv1, ...protobufDidDocument.context]
+		}()
+
+		const specCompliant = {
+			'@context': context,
+			id: protobufDidDocument.id,
+			controller: protobufDidDocument.controller,
+			verificationMethod: verificationMethod,
+			authentication: protobufDidDocument.authentication,
+			assertionMethod: protobufDidDocument.assertionMethod,
+			capabilityInvocation: protobufDidDocument.capabilityInvocation,
+			capabilityDelegation: protobufDidDocument.capabilityDelegation,
+			keyAgreement: protobufDidDocument.keyAgreement,
+			service: service,
+			alsoKnownAs: protobufDidDocument.alsoKnownAs,
+		} as DIDDocument
+
+		if (!protobufDidDocument.authentication?.length) delete specCompliant.authentication
+		if (!protobufDidDocument.assertionMethod?.length) delete specCompliant.assertionMethod
+		if (!protobufDidDocument.capabilityInvocation?.length) delete specCompliant.capabilityInvocation
+		if (!protobufDidDocument.capabilityDelegation?.length) delete specCompliant.capabilityDelegation
+		if (!protobufDidDocument.keyAgreement?.length) delete specCompliant.keyAgreement
+		if (!protobufDidDocument.service?.length) delete specCompliant.service
+		if (!protobufDidDocument.alsoKnownAs?.length) delete specCompliant.alsoKnownAs
+
+		return specCompliant
+	}
+
+	static async toSpecCompliantMetadata(protobufDidDocument: Metadata): Promise<DIDDocumentMetadata> {
+		return {
+			created: protobufDidDocument.created?.toISOString(),
+			updated: protobufDidDocument.updated?.toISOString(),
+			deactivated: protobufDidDocument.deactivated,
+			versionId: protobufDidDocument.versionId,
+			nextVersionId: protobufDidDocument?.nextVersionId,
+		}
+	}
+
 	static async generateCreateDidDocFees(feePayer: string, granter?: string): Promise<DidStdFee> {
 		return {
 			amount: [
-				DIDModule.fees.DefaultCreateDidFee
+				DIDModule.fees.DefaultCreateDidDocFee
 			],
 			gas: '360000',
 			payer: feePayer,
@@ -369,7 +543,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 	static async generateUpdateDidDocFees(feePayer: string, granter?: string): Promise<DidStdFee> {
 		return {
 			amount: [
-				DIDModule.fees.DefaultUpdateDidFee
+				DIDModule.fees.DefaultUpdateDidDocFee
 			],
 			gas: '360000',
 			payer: feePayer,
@@ -380,7 +554,7 @@ export class DIDModule extends AbstractCheqdSDKModule {
 	static async generateDeactivateDidDocFees(feePayer: string, granter?: string): Promise<DidStdFee> {
 		return {
 			amount: [
-				DIDModule.fees.DefaultDeactivateDidFee
+				DIDModule.fees.DefaultDeactivateDidDocFee
 			],
 			gas: '360000',
 			payer: feePayer,
@@ -388,21 +562,3 @@ export class DIDModule extends AbstractCheqdSDKModule {
 		} as DidStdFee
 	}
 }
-
-export type MinimalImportableDIDModule = MinimalImportableCheqdSDKModule<DIDModule>
-
-export interface DidExtension extends CheqdExtension<string, {}> {
-	did: {}
-}
-
-export const setupDidExtension = (base: QueryClient): DidExtension => {
-	const rpc = createProtobufRpcClient(base)
-
-	/* const queryService = new QueryClientImpl(rpc) */
-
-	return {
-		did: {
-			//...
-		}
-	}
-}

package/src/modules/resource.ts

@@ -1,11 +1,16 @@
-import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
+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/cheqd/resource/v2"
-import { DeliverTxResponse } from "@cosmjs/stargate"
+import { DidStdFee, IContext, ISignInputs, QueryExtensionSetup } from '../types';
+import { Metadata, MsgCreateResource, MsgCreateResourcePayload, MsgCreateResourceResponse, QueryClientImpl, QueryCollectionResourcesResponse, ResourceWithMetadata, protobufPackage } from "@cheqd/ts-proto/cheqd/resource/v2"
+import { DeliverTxResponse, QueryClient, createPagination, createProtobufRpcClient } from "@cosmjs/stargate"
 import { SignInfo } from "@cheqd/ts-proto/cheqd/did/v2";
 import { fromBuffer } from "file-type";
+import { assert } from '@cosmjs/utils';
+import { PageRequest } from '@cheqd/ts-proto/cosmos/base/query/v1beta1/pagination';
+import { CheqdQuerier } from '../querier';
+
+export const defaultResourceExtensionKey = 'resource' as const
 
 export const protobufLiterals = {
 	MsgCreateResource: 'MsgCreateResource',
@@ -24,6 +29,41 @@ export function isMsgCreateResourceEncodeObject(obj: EncodeObject): obj is MsgCr
 	return obj.typeUrl === typeUrlMsgCreateResource
 }
 
+export type MinimalImportableResourceModule = MinimalImportableCheqdSDKModule<ResourceModule>
+
+export type ResourceExtension = {
+	readonly [defaultResourceExtensionKey]: {
+		readonly resource: (collectionId: string, resourceId: string) => Promise<ResourceWithMetadata>
+		readonly resourceMetadata: (collectionId: string, resourceId: string) => Promise<Metadata>
+		readonly collectionResources: (collectionId: string, paginationKey?: Uint8Array) => Promise<QueryCollectionResourcesResponse>
+	}
+}
+
+export const setupResourceExtension = (base: QueryClient): ResourceExtension => {
+	const rpc = createProtobufRpcClient(base)
+
+	const queryService = new QueryClientImpl(rpc)
+
+	return {
+		[defaultResourceExtensionKey]: {
+			resource: async (collectionId: string, resourceId: string) => {
+				const { resource } = await queryService.Resource({ collectionId, id: resourceId })
+				assert(resource)
+				return resource
+			},
+			resourceMetadata: async (collectionId: string, resourceId: string) => {
+				const { resource } = await queryService.ResourceMetadata({ collectionId, id: resourceId })
+				assert(resource)
+				return resource
+			},
+			collectionResources: async (collectionId: string, paginationKey?: Uint8Array) => {
+				const response = await queryService.CollectionResources({ collectionId, pagination: createPagination(paginationKey) as PageRequest | undefined })
+				return response
+			}
+		}
+	} as ResourceExtension
+}
+
 export class ResourceModule extends AbstractCheqdSDKModule {
 	static readonly registryTypes: Iterable<[string, GeneratedType]> = [
 		[typeUrlMsgCreateResource, MsgCreateResource],
@@ -38,15 +78,27 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		DefaultCreateResourceDefaultFee: { amount: '5000000000', denom: ResourceModule.baseMinimalDenom } as const,
 	} as const
 
-	constructor(signer: CheqdSigningStargateClient) {
-		super(signer)
+	static readonly querierExtensionSetup: QueryExtensionSetup<ResourceExtension> = setupResourceExtension
+
+	readonly querier: CheqdQuerier & ResourceExtension
+
+	constructor(signer: CheqdSigningStargateClient, querier: CheqdQuerier & ResourceExtension) {
+		super(signer, querier)
+		this.querier = querier
 		this.methods = {
-			createResourceTx: this.createResourceTx.bind(this)
+			createLinkedResourceTx: this.createLinkedResourceTx.bind(this),
+			queryLinkedResource: this.queryLinkedResource.bind(this),
+			queryLinkedResourceMetadata: this.queryLinkedResourceMetadata.bind(this),
+			queryLinkedResources: this.queryLinkedResources.bind(this),
 		}
 	}
 
 	public getRegistryTypes(): Iterable<[string, GeneratedType]> {
-		return []
+		return ResourceModule.registryTypes
+	}
+
+	public getQuerierExtensionSetup(): QueryExtensionSetup<ResourceExtension> {
+		return ResourceModule.querierExtensionSetup
 	}
 
 	static async signPayload(payload: MsgCreateResourcePayload, signInputs: ISignInputs[] | SignInfo[]): Promise<MsgCreateResource> {
@@ -57,14 +109,14 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		} else {
 			signatures = signInputs
 		}
-		
+
 		return {
 			payload,
 			signatures
 		}
 	}
 
-	async createResourceTx(signInputs: ISignInputs[] | SignInfo[], resourcePayload: Partial<MsgCreateResourcePayload>, address: string, fee?: DidStdFee | 'auto' | number, memo?: string, context?: IContext): Promise<DeliverTxResponse> {
+	async createLinkedResourceTx(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
 		}
@@ -110,6 +162,18 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		)
 	}
 
+	async queryLinkedResource(collectionId: string, resourceId: string, context?: IContext): Promise<ResourceWithMetadata> {
+		return await this.querier[defaultResourceExtensionKey].resource(collectionId, resourceId)
+	}
+
+	async queryLinkedResourceMetadata(collectionId: string, resourceId: string, context?: IContext): Promise<Metadata> {
+		return await this.querier[defaultResourceExtensionKey].resourceMetadata(collectionId, resourceId)
+	}
+
+	async queryLinkedResources(collectionId: string, context?: IContext): Promise<QueryCollectionResourcesResponse> {
+		return await this.querier[defaultResourceExtensionKey].collectionResources(collectionId)
+	}
+
 	static async readMimeType(content: Uint8Array): Promise<string> {
 		return (await fromBuffer(content))?.mime ?? 'application/octet-stream'
 	}
@@ -147,5 +211,3 @@ export class ResourceModule extends AbstractCheqdSDKModule {
 		} as DidStdFee
 	}
 }
-
-export type MinimalImportableResourcesModule = MinimalImportableCheqdSDKModule<ResourceModule>

package/src/querier.ts

@@ -0,0 +1,33 @@
+import { QueryClient } from "@cosmjs/stargate";
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryExtensionSetup, CheqdExtensions } from "./types";
+
+export class CheqdQuerier extends QueryClient {
+    constructor(tmClient: Tendermint34Client) {
+        super(tmClient)
+    }
+
+    static async connect(url: string): Promise<CheqdQuerier> {
+        const tmClient = await Tendermint34Client.connect(url);
+        return new CheqdQuerier(tmClient);
+    }
+
+    static async fromClient(client: Tendermint34Client): Promise<CheqdQuerier> {
+        return new CheqdQuerier(client);
+    }
+
+    static async connectWithExtension(url: string, extension: QueryExtensionSetup<CheqdExtensions>): Promise<CheqdQuerier & CheqdExtensions> {
+        const tmClient = await Tendermint34Client.connect(url);
+        return CheqdQuerier.withExtensions(tmClient, extension);
+    }
+
+    static async connectWithExtensions(url: string, ...extensions: QueryExtensionSetup<CheqdExtensions>[]): Promise<CheqdQuerier & CheqdExtensions> {
+        if (extensions.length === 1) {
+            return CheqdQuerier.connectWithExtension(url, extensions[0]);
+        }
+
+        const tmClient = await Tendermint34Client.connect(url);
+        const tupleLike = extensions as [QueryExtensionSetup<CheqdExtensions>, QueryExtensionSetup<CheqdExtensions>];
+        return CheqdQuerier.withExtensions(tmClient, ...tupleLike);
+    }
+}

package/src/signer.ts

@@ -1,4 +1,3 @@
-import { CheqdExtensions } from './modules/_'
 import { EncodeObject, isOfflineDirectSigner, OfflineSigner, encodePubkey, TxBodyEncodeObject, makeSignDoc } from "@cosmjs/proto-signing"
 import { DeliverTxResponse, GasPrice, HttpEndpoint, SigningStargateClient, SigningStargateClientOptions, calculateFee, SignerData } from "@cosmjs/stargate"
 import { Tendermint34Client } from "@cosmjs/tendermint-rpc"
@@ -53,9 +52,7 @@ export function makeDidAuthInfoBytes(
 	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
@@ -184,7 +181,7 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 		return this.didSigners[verificationMethod]!
 	}
 
-	async signCreateDidTx(signInputs: ISignInputs[], payload: MsgCreateDidDocPayload): Promise<SignInfo[]> {
+	async signcreateDidDocTx(signInputs: ISignInputs[], payload: MsgCreateDidDocPayload): Promise<SignInfo[]> {
 		await this.checkDidSigners(payload?.verificationMethod)
 
 		const signBytes = MsgCreateDidDocPayload.encode(payload).finish()
@@ -198,7 +195,7 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 		return signInfos
 	}
 
-	async signUpdateDidTx(signInputs: ISignInputs[], payload: MsgUpdateDidDocPayload): Promise<SignInfo[]> {
+	async signupdateDidDocTx(signInputs: ISignInputs[], payload: MsgUpdateDidDocPayload): Promise<SignInfo[]> {
 		await this.checkDidSigners(payload?.verificationMethod)
 
 		const signBytes = MsgUpdateDidDocPayload.encode(payload).finish()
@@ -212,7 +209,7 @@ export class CheqdSigningStargateClient extends SigningStargateClient {
 		return signInfos
 	}
 
-	async signDeactivateDidTx(signInputs: ISignInputs[], payload: MsgDeactivateDidDocPayload, verificationMethod: VerificationMethod[]): Promise<SignInfo[]> {
+	async signdeactivateDidDocTx(signInputs: ISignInputs[], payload: MsgDeactivateDidDocPayload, verificationMethod: VerificationMethod[]): Promise<SignInfo[]> {
 		await this.checkDidSigners(verificationMethod)
 
 		const signBytes = MsgDeactivateDidDocPayload.encode(payload).finish()

package/src/types.ts

@@ -2,6 +2,10 @@ import { Service as ProtobufService, VerificationMethod as ProtobufVerificationM
 import { CheqdSDK } from "."
 import { Coin } from "@cosmjs/proto-signing"
 import { Signer } from "did-jwt"
+import { QueryClient } from "@cosmjs/stargate"
+import { DIDResolutionResult } from "did-resolver"
+import { DidExtension } from "./modules/did"
+import { ResourceExtension } from './modules/resource';
 export { DIDDocument, VerificationMethod, Service, ServiceEndpoint, JsonWebKey } from "did-resolver"
 
 export enum CheqdNetwork {
@@ -9,6 +13,16 @@ export enum CheqdNetwork {
     Testnet = 'testnet',
 }
 
+export type QueryExtensionSetup<T> = (base: QueryClient) => T
+
+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
+}[K]
+
+export type CheqdExtensions = DidExtension | ResourceExtension
+
 export interface IModuleMethod {
     (...args: any[]): Promise<any>
 }
@@ -19,6 +33,8 @@ export interface IContext {
     sdk: CheqdSDK
 }
 
+export type DIDDocumentWithMetadata = Pick<DIDResolutionResult, 'didDocument' | 'didDocumentMetadata'>
+
 export type SpecValidationResult = {
     valid: boolean
     error?: string
@@ -79,7 +95,7 @@ export interface DidStdFee {
 }
 
 export const ISignInputs = {
-  isSignInput(object: Object[]): object is ISignInputs[] {
+    isSignInput(object: Object[]): object is ISignInputs[] {
 		return object.some((x)=> 'privateKeyHex' in x)
 	}
 }

package/src/utils.ts

@@ -102,7 +102,7 @@ export function createKeyPairHex(seed?: string): IKeyPair {
 export function createVerificationKeys(publicKey: string, algo: MethodSpecificIdAlgo, key: TVerificationKey<TVerificationKeyPrefix, number>, network: CheqdNetwork = CheqdNetwork.Testnet): IVerificationKeys {
     let methodSpecificId: TMethodSpecificId
     let didUrl: IVerificationKeys['didUrl']
-    
+
     publicKey = publicKey.length == 43 ? publicKey : toString(fromString(publicKey, 'hex'), 'base64')
     switch (algo) {
         case MethodSpecificIdAlgo.Base58: