@cheqd/sdk 1.0.0

package/src/index.ts

@@ -0,0 +1,90 @@
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { DIDModule, MinimalImportableDIDModule } from './modules/did'
+import { MinimalImportableResourcesModule, ResourcesModule } from './modules/resources'
+import { AbstractCheqdSDKModule, applyMixins, instantiateCheqdSDKModule, } from './modules/_'
+import { CheqdSigningStargateClient } from './signer'
+import { CheqdNetwork, IContext, IModuleMethodMap } from './types'
+
+export interface ICheqdSDKOptions {
+    modules: AbstractCheqdSDKModule[]
+    authorizedMethods?: string[]
+    network?: CheqdNetwork
+    rpcUrl: string
+    readonly wallet: OfflineSigner
+}
+
+export type DefaultCheqdSDKModules = MinimalImportableDIDModule & MinimalImportableResourcesModule
+
+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, {})
+    }
+
+    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
+    }
+
+    async build() {
+        this.signer = await CheqdSigningStargateClient.connectWithSigner(
+            this.options.rpcUrl,
+            this.options.wallet
+        )
+
+        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] }), {})
+}
+
+export async function createCheqdSDK(options: ICheqdSDKOptions): Promise<CheqdSDK> {
+    return await (new CheqdSDK(options)).build()
+}
+
+export { DIDModule, ResourcesModule }

package/src/modules/_.ts

@@ -0,0 +1,58 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing"
+import { QueryClient } from "@cosmjs/stargate"
+import { CheqdSigningStargateClient } from '../signer'
+import { IModuleMethodMap } from "../types"
+import { 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 []
+    }
+}
+
+export type MinimalImportableCheqdSDKModule<T extends AbstractCheqdSDKModule> = Omit<T, '_signer' | '_protectedMethods'>
+
+export function instantiateCheqdSDKModule<T extends new (...args: any[]) => T>(module: T, ...args: ConstructorParameters<T>): T {
+    return new module(...args)
+}
+
+export function applyMixins(derivedCtor: any, constructors: any[]): 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
+
+            methods = { ...methods, [name]: property }
+        });
+    });
+
+    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
+}[K]
+
+export type CheqdExtensions = CheqdExtension<'did' | 'resources', any>
+
+export const setupCheqdExtensions = (base: QueryClient): CheqdExtensions => {
+    return {
+        ...setupDidExtension(base),
+        /** setupResourcesExtension(base) */
+    }
+}

package/src/modules/did.ts

@@ -0,0 +1,87 @@
+import { createProtobufRpcClient, DeliverTxResponse, QueryClient, StdFee } 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"
+
+export class DIDModule extends AbstractCheqdSDKModule {
+    constructor(signer: CheqdSigningStargateClient){
+        super(signer)
+        this.methods = {
+            createDidTx: this.createDidTx.bind(this),
+            updateDidTx: this.updateDidTx.bind(this)
+        }
+    }
+
+    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: {}
+}
+
+export const setupDidExtension = (base: QueryClient): DidExtension => {
+    const rpc = createProtobufRpcClient(base)
+
+    /* const queryService = new QueryClientImpl(rpc) */
+
+    return {
+        did: {
+            //...
+        }
+    }
+}

package/src/modules/resources.ts

@@ -0,0 +1,11 @@
+import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from "./_"
+import { CheqdSigningStargateClient } from "../signer"
+
+
+export class ResourcesModule extends AbstractCheqdSDKModule {
+    constructor(signer: CheqdSigningStargateClient) {
+        super(signer)
+    }
+}
+
+export type MinimalImportableResourcesModule = MinimalImportableCheqdSDKModule<ResourcesModule>

package/src/registry.ts

@@ -0,0 +1,71 @@
+import {
+    Registry,
+    GeneratedType,
+    EncodeObject
+} from '@cosmjs/proto-signing'
+
+import {
+    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 MsgUpdateDidResponseEncodeObject(obj: EncodeObject): obj is MsgUpdateDidResponseEncodeObject {
+    return obj.typeUrl === typeUrlMsgUpdateDidResponse
+}

package/src/signer.ts

@@ -0,0 +1,229 @@
+import { CheqdExtensions } from './modules/_'
+import { EncodeObject, isOfflineDirectSigner, OfflineSigner, encodePubkey, TxBodyEncodeObject, makeSignDoc } 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"
+import { MsgCreateDidPayload, SignInfo, MsgUpdateDidPayload } from '@cheqd/ts-proto/cheqd/v1/tx';
+import { DidStdFee, ISignInputs, TSignerAlgo, VerificationMethods } from './types'
+import { VerificationMethod } from '@cheqd/ts-proto/cheqd/v1/did'
+import { base64ToBytes, EdDSASigner, hexToBytes, Signer } from 'did-jwt'
+import { toString } from 'uint8arrays'
+import { assert, assertDefined } from '@cosmjs/utils'
+import { encodeSecp256k1Pubkey } from '@cosmjs/amino'
+import { Int53 } from '@cosmjs/math'
+import { fromBase64 } from '@cosmjs/encoding'
+import { AuthInfo, SignerInfo, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx'
+import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing'
+import { Any } from 'cosmjs-types/google/protobuf/any'
+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)
+}
+
+export function makeSignerInfos(
+    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),
+        }),
+    );
+}
+
+export function makeDidAuthInfoBytes(
+    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()
+}
+
+
+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
+    }
+}

package/src/types.ts

@@ -0,0 +1,67 @@
+import { CheqdSDK } from "."
+import { EdDSASigner, Signer } from 'did-jwt'
+import { Coin } from "@cosmjs/proto-signing"
+
+export enum CheqdNetwork {
+    Mainnet = 'mainnet',
+    Testnet = 'testnet',
+}
+
+export interface IModuleMethod {
+    (...args: any[]): Promise<any>
+}
+
+export interface IModuleMethodMap extends Record<string, IModuleMethod> {}
+
+export interface IContext {
+    sdk: CheqdSDK
+}
+
+export enum VerificationMethods {
+    Base58 = 'Ed25519VerificationKey2020',
+    JWK = 'JsonWebKey2020',
+}
+
+export enum MethodSpecificIdAlgo {
+    Base58 = 'base58btc',
+    Uuid = 'uuid',
+}
+
+export type TSignerAlgo = {
+    [key in VerificationMethods as string]?: (secretKey: Uint8Array) => Signer
+}
+
+export interface ISignInputs {
+    verificationMethodId: string
+    privateKeyHex: string
+}
+
+export interface IKeyPair {
+    publicKey: string
+    privateKey: string
+}
+
+export interface IKeyValuePair {
+    key: string
+    value: any
+}
+
+export type TVerificationKeyPrefix = string
+
+export type TVerificationKey<K extends TVerificationKeyPrefix, N extends number> = `${K}-${N}`
+
+export interface IVerificationKeys {
+    readonly methodSpecificId: TMethodSpecificId
+    readonly didUrl: `did:cheqd:${CheqdNetwork}:${IVerificationKeys['methodSpecificId']}` extends string ? string : never
+    readonly keyId: `${IVerificationKeys['didUrl']}#${TVerificationKey<TVerificationKeyPrefix, number>}`
+    readonly publicKey: string
+}
+
+export type TMethodSpecificId = string
+
+export interface DidStdFee {
+    readonly amount: readonly Coin[]
+    readonly gas: string
+    payer?: string
+    granter?: string
+}

package/tests/index.test.ts

@@ -0,0 +1,63 @@
+import { DirectSecp256k1HdWallet } 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'
+
+describe(
+    'CheqdSDK', () => {
+        describe('constructor', () => {
+            it('can be instantiated with 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 sdkMethods = Object.keys(cheqdSDK.methods)
+                const testSigner = await CheqdSigningStargateClient.connectWithSigner(options.rpcUrl, options.wallet)
+                const moduleMethods = Object.keys(new DIDModule(testSigner).methods)
+
+                moduleMethods.forEach((method) => {
+                    expect(sdkMethods).toContain(method)
+                })
+            })
+
+            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 {
+                    methods = {
+                        doSomething: this.doSomething.bind(this)
+                    }
+                    constructor(signer: CheqdSigningStargateClient) {
+                        super(signer)
+                    }
+                    async doSomething(): Promise<string> {
+                        return 'did something'
+                    }
+                }
+                const options = {
+                    modules: [TestModule as unknown as AbstractCheqdSDKModule],
+                    rpcUrl,
+                    wallet 
+                } as ICheqdSDKOptions
+
+                const cheqdSDK = await createCheqdSDK(options)
+
+                //@ts-ignore
+                const doSomething = await cheqdSDK.doSomething()
+                expect(doSomething).toBe('did something')
+
+                //@ts-ignore
+                const spy = jest.spyOn(cheqdSDK.methods, 'doSomething')
+                //@ts-ignore
+                await cheqdSDK.doSomething()
+                expect(spy).toHaveBeenCalled()
+            })
+        })
+    }
+)