@cheqd/sdk 2.1.0-develop.1 → 2.2.0

package/src/modules/resource.ts

@@ -1,213 +0,0 @@
-import { AbstractCheqdSDKModule, MinimalImportableCheqdSDKModule } from './_';
-import { CheqdSigningStargateClient } from "../signer"
-import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing"
-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',
-	MsgCreateResourceResponse: 'MsgCreateResourceResponse'
-} as const
-
-export const typeUrlMsgCreateResource = `/${protobufPackage}.${protobufLiterals.MsgCreateResource}`
-export const typeUrlMsgCreateResourceResponse = `/${protobufPackage}.${protobufLiterals.MsgCreateResourceResponse}`
-
-export interface MsgCreateResourceEncodeObject extends EncodeObject {
-	readonly typeUrl: typeof typeUrlMsgCreateResource,
-	readonly value: Partial<MsgCreateResource>
-}
-
-export function isMsgCreateResourceEncodeObject(obj: EncodeObject): obj is MsgCreateResourceEncodeObject {
-	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],
-		[typeUrlMsgCreateResourceResponse, MsgCreateResourceResponse]
-	]
-
-	static readonly baseMinimalDenom = 'ncheq' as const
-
-	static readonly fees = {
-		DefaultCreateResourceImageFee: { amount: '10000000000', denom: ResourceModule.baseMinimalDenom } as const,
-		DefaultCreateResourceJsonFee: { amount: '2500000000', denom: ResourceModule.baseMinimalDenom } as const,
-		DefaultCreateResourceDefaultFee: { amount: '5000000000', denom: ResourceModule.baseMinimalDenom } as const,
-	} as const
-
-	static readonly querierExtensionSetup: QueryExtensionSetup<ResourceExtension> = setupResourceExtension
-
-	readonly querier: CheqdQuerier & ResourceExtension
-
-	constructor(signer: CheqdSigningStargateClient, querier: CheqdQuerier & ResourceExtension) {
-		super(signer, querier)
-		this.querier = querier
-		this.methods = {
-			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 ResourceModule.registryTypes
-	}
-
-	public getQuerierExtensionSetup(): QueryExtensionSetup<ResourceExtension> {
-		return ResourceModule.querierExtensionSetup
-	}
-
-	static async signPayload(payload: MsgCreateResourcePayload, signInputs: ISignInputs[] | SignInfo[]): Promise<MsgCreateResource> {
-		const signBytes = MsgCreateResourcePayload.encode(payload).finish()
-		let signatures: SignInfo[]
-		if(ISignInputs.isSignInput(signInputs)) {
-			signatures = await CheqdSigningStargateClient.signIdentityTx(signBytes, signInputs)
-		} else {
-			signatures = signInputs
-		}
-
-		return {
-			payload,
-			signatures
-		}
-	}
-
-	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
-		}
-
-		const payload = MsgCreateResourcePayload.fromPartial(resourcePayload)
-
-		const msg = await ResourceModule.signPayload(payload, signInputs)
-
-		const encObj: MsgCreateResourceEncodeObject = {
-			typeUrl: typeUrlMsgCreateResource,
-			value: msg
-		}
-
-		if (address === '') {
-			address = (await context!.sdk!.options.wallet.getAccounts())[0].address
-		}
-
-		if (!fee) {
-			if (payload.data.length === 0) {
-				throw new Error('Linked resource data is empty')
-			}
-
-			fee = await async function() {
-				const mimeType = await ResourceModule.readMimeType(payload.data)
-
-				if (mimeType.startsWith('image/')) {
-					return await ResourceModule.generateCreateResourceImageFees(address)
-				}
-
-				if (mimeType.startsWith('application/json')) {
-					return await ResourceModule.generateCreateResourceJsonFees(address)
-				}
-
-				return await ResourceModule.generateCreateResourceDefaultFees(address)
-			}()
-		}
-
-		return this._signer.signAndBroadcast(
-			address,
-			[encObj],
-			fee!,
-			memo
-		)
-	}
-
-	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'
-	}
-
-	static async generateCreateResourceImageFees(feePayer: string, granter?: string): Promise<DidStdFee> {
-		return {
-			amount: [
-				ResourceModule.fees.DefaultCreateResourceImageFee
-			],
-			gas: '360000',
-			payer: feePayer,
-			granter: granter
-		} as DidStdFee
-	}
-
-	static async generateCreateResourceJsonFees(feePayer: string, granter?: string): Promise<DidStdFee> {
-		return {
-			amount: [
-				ResourceModule.fees.DefaultCreateResourceJsonFee
-			],
-			gas: '360000',
-			payer: feePayer,
-			granter: granter
-		} as DidStdFee
-	}
-
-	static async generateCreateResourceDefaultFees(feePayer: string, granter?: string): Promise<DidStdFee> {
-		return {
-			amount: [
-				ResourceModule.fees.DefaultCreateResourceDefaultFee
-			],
-			gas: '360000',
-			payer: feePayer,
-			granter: granter
-		} as DidStdFee
-	}
-}

package/src/querier.ts

@@ -1,33 +0,0 @@
-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/registry.ts

@@ -1,15 +0,0 @@
-import {
-	Registry,
-	GeneratedType,
-} from '@cosmjs/proto-signing'
-
-import {
-	defaultRegistryTypes
-} from '@cosmjs/stargate'
-
-export function createDefaultCheqdRegistry(customTypes?: Iterable<[string, GeneratedType]>): Registry {
-	if (!customTypes) customTypes = [];
-	return new Registry([...defaultRegistryTypes, ...customTypes])
-}
-
-export const CheqdRegistry = new Registry(defaultRegistryTypes)

package/src/signer.ts

@@ -1,258 +0,0 @@
-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"
-import { createDefaultCheqdRegistry } from "./registry"
-import { MsgCreateDidDocPayload, SignInfo, MsgUpdateDidDocPayload, MsgDeactivateDidDocPayload, VerificationMethod } from '@cheqd/ts-proto/cheqd/did/v2';
-import { DidStdFee, ISignInputs, TSignerAlgo, VerificationMethods } from './types';
-import { base64ToBytes, EdDSASigner, hexToBytes, Signer, ES256Signer, ES256KSigner } from 'did-jwt';
-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 {
-	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
-	}
-
-	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)
-	}
-
-	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.verificationMethodType ?? '')) {
-				throw new Error(`Unsupported verification method type: ${verificationMethod.verificationMethodType}`)
-			}
-			if (!this.didSigners[verificationMethod.verificationMethodType ?? '']) {
-				this.didSigners[verificationMethod.verificationMethodType ?? ''] = 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)?.verificationMethodType
-		if (!verificationMethod) {
-			throw new Error(`Verification method for ${verificationMethodId} not found`)
-		}
-		return this.didSigners[verificationMethod]!
-	}
-
-	async signcreateDidDocTx(signInputs: ISignInputs[], payload: MsgCreateDidDocPayload): Promise<SignInfo[]> {
-		await this.checkDidSigners(payload?.verificationMethod)
-
-		const signBytes = MsgCreateDidDocPayload.encode(payload).finish()
-		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
-			return {
-				verificationMethodId: signInput.verificationMethodId,
-				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
-			}
-		}))
-
-		return signInfos
-	}
-
-	async signupdateDidDocTx(signInputs: ISignInputs[], payload: MsgUpdateDidDocPayload): Promise<SignInfo[]> {
-		await this.checkDidSigners(payload?.verificationMethod)
-
-		const signBytes = MsgUpdateDidDocPayload.encode(payload).finish()
-		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
-			return {
-				verificationMethodId: signInput.verificationMethodId,
-				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, payload.verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
-			}
-		}))
-
-		return signInfos
-	}
-
-	async signdeactivateDidDocTx(signInputs: ISignInputs[], payload: MsgDeactivateDidDocPayload, verificationMethod: VerificationMethod[]): Promise<SignInfo[]> {
-		await this.checkDidSigners(verificationMethod)
-
-		const signBytes = MsgDeactivateDidDocPayload.encode(payload).finish()
-		const signInfos: SignInfo[] = await Promise.all(signInputs.map(async (signInput) => {
-			return {
-				verificationMethodId: signInput.verificationMethodId,
-				signature: base64ToBytes((await (await this.getDidSigner(signInput.verificationMethodId, verificationMethod))(hexToBytes(signInput.privateKeyHex))(signBytes)) as string)
-			}
-		}))
-
-		return signInfos
-	}
-
-	static async signIdentityTx(signBytes: Uint8Array, signInputs: ISignInputs[]): Promise<SignInfo[]> {
-		let signInfos: SignInfo[] = [];
-
-		for (let signInput of signInputs) {
-			if (typeof(signInput.keyType) === undefined) {
-				throw new Error('Key type is not defined')
-			}
-
-			let signature: string;
-
-			switch (signInput.keyType) {
-				case 'Ed25519':
-					signature = (await EdDSASigner(hexToBytes(signInput.privateKeyHex))(signBytes)) as string;
-					break;
-				case 'Secp256k1':
-					signature = (await ES256KSigner(hexToBytes(signInput.privateKeyHex))(signBytes)) as string;
-					break;
-				case 'P256':
-					signature = (await ES256Signer(hexToBytes(signInput.privateKeyHex))(signBytes)) as string;
-					break;
-				default:
-					throw new Error(`Unsupported signature type: ${signInput.keyType}`);
-			}
-
-			signInfos.push({
-				verificationMethodId: signInput.verificationMethodId,
-				signature: base64ToBytes(signature)
-			});
-		}
-
-		return signInfos
-	}
-}

package/src/types.ts

@@ -1,101 +0,0 @@
-import { Service as ProtobufService, VerificationMethod as ProtobufVerificationMethod } from "@cheqd/ts-proto/cheqd/did/v2"
-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 {
-    Mainnet = 'mainnet',
-    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>
-}
-
-export interface IModuleMethodMap extends Record<string, IModuleMethod> {}
-
-export interface IContext {
-    sdk: CheqdSDK
-}
-
-export type DIDDocumentWithMetadata = Pick<DIDResolutionResult, 'didDocument' | 'didDocumentMetadata'>
-
-export type SpecValidationResult = {
-    valid: boolean
-    error?: string
-    protobufVerificationMethod?: ProtobufVerificationMethod[]
-    protobufService?: ProtobufService[]
-}
-
-export enum VerificationMethods {
-    Ed255192020 = 'Ed25519VerificationKey2020',
-    Ed255192018 = 'Ed25519VerificationKey2018',
-    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
-    keyType?: 'Ed25519' | 'Secp256k1' | 'P256'
-    privateKeyHex: string
-}
-
-export interface IKeyPair {
-    publicKey: string
-    privateKey: string
-    algo?: MethodSpecificIdAlgo
-}
-
-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
-}
-
-export const ISignInputs = {
-    isSignInput(object: Object[]): object is ISignInputs[] {
-		return object.some((x)=> 'privateKeyHex' in x)
-	}
-}