@cheqd/sdk 2.1.0-develop.1 → 2.2.0

package/src/index.ts

@@ -1,128 +0,0 @@
-import { OfflineSigner, Registry } from '@cosmjs/proto-signing'
-import { DIDModule, MinimalImportableDIDModule, DidExtension } from './modules/did';
-import { MinimalImportableResourceModule, ResourceModule, ResourceExtension } from './modules/resource';
-import { AbstractCheqdSDKModule, applyMixins, instantiateCheqdSDKModule, instantiateCheqdSDKModuleRegistryTypes, instantiateCheqdSDKModuleQuerierExtensionSetup } from './modules/_';
-import { createDefaultCheqdRegistry } from './registry'
-import { CheqdSigningStargateClient } from './signer'
-import { CheqdNetwork, IContext, IModuleMethodMap } from './types';
-import { createSignInputsFromImportableEd25519Key } from './utils'
-import { GasPrice, QueryClient } from '@cosmjs/stargate'
-import { CheqdQuerier } from './querier'
-import { Tendermint34Client } from '@cosmjs/tendermint-rpc'
-
-export interface ICheqdSDKOptions {
-	modules: AbstractCheqdSDKModule[]
-	querierExtensions?: Record<string, any>[] 
-	rpcUrl: string
-	network?: CheqdNetwork
-	gasPrice?: GasPrice
-	authorizedMethods?: string[]
-	readonly wallet: OfflineSigner
-}
-
-export type DefaultCheqdSDKModules = MinimalImportableDIDModule & MinimalImportableResourceModule
-
-export interface CheqdSDK extends DefaultCheqdSDKModules {}
-
-export class CheqdSDK {
-	methods: IModuleMethodMap
-	signer: CheqdSigningStargateClient
-	querier: CheqdQuerier & DidExtension & ResourceExtension
-	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, {})
-		this.querier = <any> new QueryClient({} as unknown as Tendermint34Client)
-	}
-
-	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 async loadModules(modules: AbstractCheqdSDKModule[]): Promise<CheqdSDK> {
-		this.options.modules = this.options.modules.map((module: any) => instantiateCheqdSDKModule(module, this.signer, this.querier, { 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)
-    }
-
-	private async loadQuerierExtensions(): Promise<CheqdQuerier & DidExtension & ResourceExtension> {
-		const querierExtensions = this.options.modules.map((module: any) => instantiateCheqdSDKModuleQuerierExtensionSetup(module))
-		const querier = await CheqdQuerier.connectWithExtensions(this.options.rpcUrl, ...querierExtensions)
-		return <CheqdQuerier & DidExtension & ResourceExtension>querier
-	}
-
-	async build(): Promise<CheqdSDK> {
-        const registry = this.loadRegistry()
-
-		this.querier = await this.loadQuerierExtensions()
-		this.signer = await CheqdSigningStargateClient.connectWithSigner(
-			this.options.rpcUrl,
-			this.options.wallet,
-            {
-                registry,
-				gasPrice: this.options?.gasPrice,
-            }
-		)
-
-		return await 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, ResourceModule }
-export { createSignInputsFromImportableEd25519Key }
-export {
-	createKeyPairRaw, 
-	createKeyPairBase64,
-	createKeyPairHex,
-	createVerificationKeys,
-	createDidVerificationMethod,
-	createDidPayload
-} from './utils'

package/src/modules/_.ts

@@ -1,55 +0,0 @@
-import { GeneratedType } from "@cosmjs/proto-signing"
-import { QueryClient } from "@cosmjs/stargate"
-import { CheqdSigningStargateClient } from '../signer'
-import { IModuleMethodMap, QueryExtensionSetup } from '../types';
-import { CheqdQuerier } from "../querier";
-
-export abstract class AbstractCheqdSDKModule {
-	_signer: CheqdSigningStargateClient
-	methods: IModuleMethodMap = {}
-	readonly querier: CheqdQuerier
-	readonly _protectedMethods: string[] = ['constructor', 'getRegistryTypes', 'getQuerierExtensionSetup']
-	static readonly registryTypes: Iterable<[string, GeneratedType]> = []
-	static readonly querierExtensionSetup: QueryExtensionSetup<any> = (base: QueryClient) => ({})
-
-	constructor(signer: CheqdSigningStargateClient, querier: CheqdQuerier) {
-		if (!signer) {
-			throw new Error("signer is required")
-		}
-		this._signer = signer
-		this.querier = querier
-	}
-
-    abstract getRegistryTypes(): Iterable<[string, GeneratedType]>
-}
-
-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' | 'querierExtensionSetup' | 'getRegistryTypes' | 'getQuerierExtensionSetup'>
-
-export function instantiateCheqdSDKModule<T extends new (...args: any[]) => T>(module: T, ...args: ConstructorParameters<T>): T {
-	return new module(...args)
-}
-
-export function instantiateCheqdSDKModuleRegistryTypes(module: any): Iterable<[string, GeneratedType]> {
-    return module.registryTypes ?? []
-}
-
-export function instantiateCheqdSDKModuleQuerierExtensionSetup(module: any): QueryExtensionSetup<any> {
-	return module.querierExtensionSetup ?? {}
-}
-
-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
-}