@cosmwasm/ts-codegen 0.30.0 → 0.31.0

package/module/plugins/client.js

@@ -1,11 +1,12 @@
-import { pascal } from 'case';
-import * as w from 'wasm-ast-types';
-import { findExecuteMsg, findAndParseTypes, findQueryMsg } from '../utils';
-import { RenderContext, getMessageProperties } from 'wasm-ast-types';
-import { BuilderPluginBase } from './plugin-base';
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { findExecuteMsg, findAndParseTypes, findQueryMsg } from "../utils";
+import { RenderContext, getMessageProperties } from "wasm-ast-types";
+import { BuilderPluginBase } from "./plugin-base";
+export const TYPE = "client";
 export class ClientPlugin extends BuilderPluginBase {
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {
@@ -20,8 +21,8 @@ export class ClientPlugin extends BuilderPluginBase {
     const {
       schemas
     } = context.contract;
-    const localname = pascal(name) + '.client.ts';
-    const TypesFile = pascal(name) + '.types';
+    const localname = pascal(name) + ".client.ts";
+    const TypesFile = pascal(name) + ".types";
     const QueryMsg = findQueryMsg(schemas);
     const ExecuteMsg = findExecuteMsg(schemas);
     const typeHash = await findAndParseTypes(schemas);
@@ -37,6 +38,7 @@ export class ClientPlugin extends BuilderPluginBase {
       ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
       body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
       body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
+      context.addProviderInfo(name, w.PROVIDER_TYPES.QUERY_CLIENT_TYPE, QueryClient, localname);
     } // execute messages
 
 
@@ -48,16 +50,17 @@ export class ClientPlugin extends BuilderPluginBase {
         Instance = pascal(`${name}Interface`);
         body.push(w.createExecuteInterface(context, Instance, this.option.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
         body.push(w.createExecuteClass(context, Client, Instance, this.option.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
+        context.addProviderInfo(name, w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE, Client, localname);
       }
     }
 
-    if (typeHash.hasOwnProperty('Coin')) {
+    if (typeHash.hasOwnProperty("Coin")) {
       // @ts-ignore
       delete context.utils.Coin;
     }
 
     return [{
-      type: 'client',
+      type: TYPE,
       localname,
       body
     }];

package/module/plugins/message-composer.js

@@ -1,11 +1,12 @@
-import { pascal } from 'case';
-import * as w from 'wasm-ast-types';
-import { findAndParseTypes, findExecuteMsg } from '../utils';
-import { getMessageProperties, RenderContext } from 'wasm-ast-types';
-import { BuilderPluginBase } from './plugin-base';
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg } from "../utils";
+import { getMessageProperties, RenderContext } from "wasm-ast-types";
+import { BuilderPluginBase } from "./plugin-base";
+export const TYPE = "message-composer";
 export class MessageComposerPlugin extends BuilderPluginBase {
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {
@@ -20,8 +21,8 @@ export class MessageComposerPlugin extends BuilderPluginBase {
     const {
       schemas
     } = context.contract;
-    const localname = pascal(name) + '.message-composer.ts';
-    const TypesFile = pascal(name) + '.types';
+    const localname = pascal(name) + ".message-composer.ts";
+    const TypesFile = pascal(name) + ".types";
     const ExecuteMsg = findExecuteMsg(schemas);
     const typeHash = await findAndParseTypes(schemas);
     const body = [];
@@ -35,16 +36,17 @@ export class MessageComposerPlugin extends BuilderPluginBase {
         const Interface = pascal(`${name}Message`);
         body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
         body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
+        context.addProviderInfo(name, w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE, TheClass, localname);
       }
     }
 
-    if (typeHash.hasOwnProperty('Coin')) {
+    if (typeHash.hasOwnProperty("Coin")) {
       // @ts-ignore
       delete context.utils.Coin;
     }
 
     return [{
-      type: 'message-composer',
+      type: TYPE,
       localname,
       body
     }];

package/module/plugins/msg-builder.js

@@ -5,7 +5,7 @@ import { getMessageProperties, RenderContext } from 'wasm-ast-types';
 import { BuilderPluginBase } from './plugin-base';
 export class MsgBuilderPlugin extends BuilderPluginBase {
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {

package/module/plugins/plugin-base.js

@@ -1,21 +1,28 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { sync as mkdirp } from 'mkdirp';
-import { join } from 'path';
-import { writeFileSync } from 'fs';
-import { header } from '../utils/header';
-import generate from '@babel/generator';
-import * as t from '@babel/types';
+import { sync as mkdirp } from "mkdirp";
+import { join } from "path";
+import { writeFileSync } from "fs";
+import { header } from "../utils/header";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
 
 /**
  * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
  */
 export class BuilderPluginBase {
-  constructor(opt) {
+  constructor(opt, builder) {
+    _defineProperty(this, "builder", void 0);
+
     _defineProperty(this, "option", void 0);
 
     _defineProperty(this, "utils", void 0);
 
     this.option = opt;
+    this.builder = builder;
+  }
+
+  setBuilder(builder) {
+    this.builder = builder;
   }
 
   async render(name, contractInfo, outPath) {
@@ -35,7 +42,7 @@ export class BuilderPluginBase {
     }
 
     return results.map(result => {
-      const imports = context.getImports(this.utils);
+      const imports = context.getImports(this.utils, result.localname);
       const code = header + generate(t.program([...imports, ...result.body])).code;
       mkdirp(outPath);
       const filename = join(outPath, result.localname);

package/module/plugins/provider-bundle.js

@@ -0,0 +1,65 @@
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { RenderContext } from "wasm-ast-types";
+import { BuilderPluginBase } from "./plugin-base";
+import { GetLocalBaseNameByContractName } from "./provider";
+export class ContractsProviderBundlePlugin extends BuilderPluginBase {
+  constructor(opt) {
+    super(opt);
+    this.utils = {
+      CosmWasmClient: "@cosmjs/cosmwasm-stargate",
+      SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
+      IQueryClientProvider: "__contractContextBase__",
+      ISigningClientProvider: "__contractContextBase__",
+      IMessageComposerProvider: "__contractContextBase__"
+    };
+  }
+
+  initContext(contract, options) {
+    return new RenderContext(contract, options, this.builder.builderContext);
+  }
+
+  async doRender(name, context) {
+    if (!this.option?.useContracts?.enabled) {
+      return;
+    }
+
+    const providerInfos = context.getProviderInfos();
+
+    if (!Object.keys(providerInfos)?.length) {
+      return;
+    }
+
+    const localname = "contractContextProviders.ts";
+    const body = [];
+    context.addUtil("CosmWasmClient");
+    context.addUtil("SigningCosmWasmClient");
+    context.addUtil("IQueryClientProvider");
+    context.addUtil("ISigningClientProvider");
+    context.addUtil("IMessageComposerProvider");
+
+    for (const name in providerInfos) {
+      if (Object.prototype.hasOwnProperty.call(providerInfos, name)) {
+        const providerInfo = providerInfos[name];
+
+        for (const key in providerInfo) {
+          if (Object.prototype.hasOwnProperty.call(providerInfo, key)) {
+            const info = providerInfo[key];
+            body.push(w.importStmt([info.classname], `./${info.basename}`));
+          }
+        }
+
+        body.push(w.importStmt([pascal(name)], `./${GetLocalBaseNameByContractName(name)}`));
+      }
+    }
+
+    body.push(w.createIContractsContext(providerInfos));
+    body.push(w.createGettingProviders(providerInfos));
+    return [{
+      type: "plugin",
+      localname,
+      body
+    }];
+  }
+
+}

package/module/plugins/provider.js

@@ -0,0 +1,81 @@
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { RenderContext } from "wasm-ast-types";
+import { BuilderPluginBase } from "./plugin-base";
+export const GetLocalNameByContractName = name => `${pascal(name)}.provider.ts`;
+export const GetLocalBaseNameByContractName = name => `${pascal(name)}.provider`;
+export class ContractsContextProviderPlugin extends BuilderPluginBase {
+  constructor(opt) {
+    super(opt);
+    this.utils = {
+      ContractBase: "__contractContextBase__",
+      IContractConstructor: "__contractContextBase__",
+      IEmptyClient: "__contractContextBase__"
+    };
+  }
+
+  initContext(contract, options) {
+    return new RenderContext(contract, options, this.builder.builderContext);
+  }
+
+  async doRender(name, context) {
+    if (!this.option?.useContracts?.enabled) {
+      return;
+    }
+
+    const providerInfo = context.getProviderInfos()[name];
+
+    if (!Object.keys(providerInfo)?.length) {
+      return;
+    }
+
+    context.addUtil("ContractBase");
+    context.addUtil("IContractConstructor");
+    const localname = GetLocalNameByContractName(name);
+    let needEmptyClientType = false;
+    let clientFile = null;
+    let clientClasses = [];
+    const body = [];
+    const signClientProviderInfo = providerInfo[w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE];
+
+    if (signClientProviderInfo) {
+      clientFile = `./${signClientProviderInfo.basename}`;
+      clientClasses.push(signClientProviderInfo.classname);
+    } else {
+      needEmptyClientType = true;
+    }
+
+    const queryClientProviderInfo = providerInfo[w.PROVIDER_TYPES.QUERY_CLIENT_TYPE];
+
+    if (queryClientProviderInfo) {
+      clientFile = `./${queryClientProviderInfo.basename}`;
+      clientClasses.push(queryClientProviderInfo.classname);
+    } else {
+      needEmptyClientType = true;
+    }
+
+    if (clientFile) {
+      body.push(w.importStmt(clientClasses, clientFile));
+    }
+
+    const messageComposerProviderInfo = providerInfo[w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE];
+
+    if (messageComposerProviderInfo) {
+      body.push(w.importStmt([messageComposerProviderInfo.classname], `./${messageComposerProviderInfo.basename}`));
+    } else {
+      needEmptyClientType = true;
+    }
+
+    if (needEmptyClientType) {
+      context.addUtil("IEmptyClient");
+    }
+
+    body.push(w.createProvider(name, providerInfo));
+    return [{
+      type: "plugin",
+      localname,
+      body
+    }];
+  }
+
+}

package/module/plugins/react-query.js

@@ -5,7 +5,7 @@ import { getMessageProperties, RenderContext } from 'wasm-ast-types';
 import { BuilderPluginBase } from './plugin-base';
 export class ReactQueryPlugin extends BuilderPluginBase {
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {

package/module/plugins/recoil.js

@@ -14,7 +14,7 @@ export class RecoilPlugin extends BuilderPluginBase {
   }
 
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {

package/module/plugins/types.js

@@ -6,7 +6,7 @@ import { RenderContext } from 'wasm-ast-types';
 import { BuilderPluginBase } from './plugin-base';
 export class TypesPlugin extends BuilderPluginBase {
   initContext(contract, options) {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(name, context) {

package/module/utils/files.js

@@ -0,0 +1,44 @@
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import { sync as mkdirp } from "mkdirp";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import generate from "@babel/generator";
+import { unused } from "./unused";
+import traverse from "@babel/traverse";
+export const writeAstToFile = (outPath, program, filename, removeUnusedImports = false, isTsDisable = false, isEslintDisable = false) => {
+  const ast = t.program(program);
+  const content = generate(ast).code;
+
+  if (removeUnusedImports) {
+    const plugins = ["typescript"];
+    const newAst = parse(content, {
+      sourceType: "module",
+      plugins
+    });
+    traverse(newAst, unused);
+    const content2 = generate(newAst).code;
+    writeContentToFile(outPath, content2, filename, isTsDisable, isEslintDisable);
+  } else {
+    writeContentToFile(outPath, content, filename, isTsDisable, isEslintDisable);
+  }
+};
+export const writeContentToFile = (outPath, content, filename, isTsDisable = false, isEslintDisable = false) => {
+  let esLintPrefix = "";
+  let tsLintPrefix = "";
+  let nameWithoutPath = filename.replace(outPath, ""); // strip off leading slash
+
+  if (nameWithoutPath.startsWith("/")) nameWithoutPath = nameWithoutPath.replace(/^\//, "");
+
+  if (isTsDisable) {
+    tsLintPrefix = `//@ts-nocheck\n`;
+  }
+
+  if (isEslintDisable) {
+    esLintPrefix = `/* eslint-disable */\n`;
+  }
+
+  const text = tsLintPrefix + esLintPrefix + content;
+  mkdirp(dirname(filename));
+  writeFileSync(filename, text);
+};

package/module/utils/schemas.js

@@ -72,8 +72,7 @@ export const findQueryMsg = schemas => {
   return QueryMsg;
 };
 export const findExecuteMsg = schemas => {
-  const ExecuteMsg = schemas.find(schema => schema.title === 'ExecuteMsg' || schema.title === 'ExecuteMsg_for_Empty' || // if cleanse is used, this is never
-  schema.title === 'ExecuteMsgForEmpty');
+  const ExecuteMsg = schemas.find(schema => schema.title.startsWith('ExecuteMsg'));
   return ExecuteMsg;
 };
 export const findAndParseTypes = async schemas => {

package/module/utils/unused.js

@@ -0,0 +1,45 @@
+//@ts-nocheck
+import * as t from '@babel/types'; // https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+
+export const unused = {
+  Program: {
+    exit: path => {
+      const UnRefBindings = new Map();
+
+      for (const [name, binding] of Object.entries(path.scope.bindings)) {
+        if (!binding.path.parentPath || binding.kind !== 'module') continue;
+        const source = binding.path.parentPath.get('source');
+        const importName = source.node.value;
+        if (!t.isStringLiteral(source)) continue;
+        const key = `${importName}(${source.node.loc && source.node.loc.start.line})`;
+
+        if (!UnRefBindings.has(key)) {
+          UnRefBindings.set(key, binding);
+        }
+
+        if (binding.referenced) {
+          UnRefBindings.set(key, null);
+        } else {
+          const nodeType = binding.path.node.type;
+
+          if (nodeType === 'ImportSpecifier') {
+            binding.path.remove();
+          } else if (nodeType === 'ImportDefaultSpecifier') {
+            binding.path.remove();
+          } else if (nodeType === 'ImportNamespaceSpecifier') {
+            binding.path.remove();
+          } else if (binding.path.parentPath) {
+            binding.path.parentPath.remove();
+          }
+        }
+      }
+
+      UnRefBindings.forEach((binding, key) => {
+        if (binding && binding.path.parentPath) {
+          binding.path.parentPath.remove();
+        }
+      });
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "@cosmwasm/ts-codegen converts your CosmWasm smart contracts into dev-friendly TypeScript classes so you can focus on shipping code.",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/cosmwasm/ts-codegen",
@@ -96,7 +96,7 @@
     "parse-package-name": "1.0.0",
     "rimraf": "3.0.2",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.23.0"
+    "wasm-ast-types": "^0.24.0"
   },
-  "gitHead": "9979ae4b7209f920fe1b822ede2ba80ee0f2eade"
+  "gitHead": "4553eb80cd89969583df6164d1c764ab5b289c63"
 }

package/src/builder/builder.ts

@@ -1,4 +1,4 @@
-import { RenderOptions, defaultOptions, RenderContext, ContractInfo, MessageComposerOptions} from "wasm-ast-types";
+import { RenderOptions, defaultOptions, RenderContext, ContractInfo, MessageComposerOptions, BuilderContext} from "wasm-ast-types";
 
 import { header } from '../utils/header';
 import { join } from "path";
@@ -21,6 +21,9 @@ import { MsgBuilderPlugin } from "../plugins/msg-builder";
 import { MessageComposerPlugin } from "../plugins/message-composer";
 import { ClientPlugin } from "../plugins/client";
 import { TypesPlugin } from "../plugins/types";
+import { ContractsContextProviderPlugin } from "../plugins/provider";
+import { createHelpers } from "../generators/create-helpers";
+import { ContractsProviderBundlePlugin } from "../plugins/provider-bundle";
 
 const defaultOpts: TSBuilderOptions = {
     bundle: {
@@ -44,8 +47,14 @@ export interface BundleOptions {
     bundlePath?: string;
 };
 
+export interface UseContractsOptions {
+  enabled?: boolean;
+  filename?: string;
+};
+
 export type TSBuilderOptions = {
     bundle?: BundleOptions;
+    useContracts?: UseContractsOptions;
 } & RenderOptions;
 
 export type BuilderFileType = 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer' | 'msg-builder' | 'plugin';
@@ -83,6 +92,7 @@ export class TSBuilder {
     outPath: string;
     options?: TSBuilderOptions;
     plugins: IBuilderPlugin[] = [];
+    builderContext: BuilderContext = new BuilderContext();
 
     protected files: BuilderFile[] = [];
 
@@ -94,6 +104,7 @@ export class TSBuilder {
             new ReactQueryPlugin(this.options),
             new RecoilPlugin(this.options),
             new MsgBuilderPlugin(this.options),
+            new ContractsContextProviderPlugin(this.options),
         ]);
     }
 
@@ -113,6 +124,8 @@ export class TSBuilder {
         if (plugins && plugins.length) {
             [].push.apply(this.plugins, plugins);
         }
+
+        this.plugins.forEach(plugin=> plugin.setBuilder(this))
     }
 
     async build() {
@@ -147,6 +160,28 @@ export class TSBuilder {
         if (this.options.bundle.enabled) {
             this.bundle();
         }
+
+        //create useContracts bundle file
+        const contractsProviderBundlePlugin = new ContractsProviderBundlePlugin(this.options);
+        contractsProviderBundlePlugin.setBuilder(this);
+
+        let files = await contractsProviderBundlePlugin.render(
+          "",
+          {
+            schemas: [],
+          },
+          this.outPath
+        );
+        if(files && files.length){
+          [].push.apply(this.files, files);
+        }
+
+        createHelpers({
+          outPath: this.outPath,
+          contracts: this.contracts,
+          options: this.options,
+          plugins: this.plugins,
+        }, this.builderContext);
     }
 
     async bundle() {

package/src/generators/create-helpers.ts

@@ -0,0 +1,28 @@
+import { join, dirname } from "path";
+import { sync as mkdirp } from "mkdirp";
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+import { TSBuilderInput } from "../builder";
+import { contractContextBase, contractsContextTSX } from "../helpers";
+import { BuilderContext } from "wasm-ast-types";
+
+const version = process.env.NODE_ENV === "test" ? "latest" : pkg.version;
+const header = `/**
+* This file and any referenced files were automatically generated by ${pkg.name}@${version}
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or yarn proto command to regenerate this bundle.
+*/
+\n`;
+
+const write = (outPath: string, file: string, content: string) => {
+  const outFile = join(outPath, file);
+  mkdirp(dirname(outFile));
+  writeContentToFile(outPath, header + content, outFile);
+};
+
+export const createHelpers = (input: TSBuilderInput, builderContext: BuilderContext) => {
+  if (input.options?.useContracts?.enabled && Object.keys(builderContext.providers)?.length) {
+    write(input.outPath, "contractContextBase.ts", contractContextBase);
+    write(input.outPath, "contracts-context.tsx", contractsContextTSX);
+  }
+};

package/src/helpers/contractContextBase.ts

@@ -0,0 +1,92 @@
+export const contractContextBase = `
+import {
+  CosmWasmClient,
+  SigningCosmWasmClient,
+} from '@cosmjs/cosmwasm-stargate';
+
+export interface IContractConstructor {
+  address: string | undefined;
+  cosmWasmClient: CosmWasmClient | undefined;
+  signingCosmWasmClient: SigningCosmWasmClient | undefined;
+}
+
+export const NO_SINGING_ERROR_MESSAGE = 'signingCosmWasmClient not connected';
+
+export const NO_COSMWASW_CLIENT_ERROR_MESSAGE = 'cosmWasmClient not connected';
+
+export const NO_ADDRESS_ERROR_MESSAGE = "address doesn't exist";
+
+export const NO_SIGNING_CLIENT_ERROR_MESSAGE =
+  'Signing client is not generated. Please check ts-codegen config';
+
+export const NO_QUERY_CLIENT_ERROR_MESSAGE =
+  'Query client is not generated. Please check ts-codegen config';
+
+export const NO_MESSAGE_COMPOSER_ERROR_MESSAGE =
+  'Message composer client is not generated. Please check ts-codegen config';
+
+/**
+ * a placeholder for non-generated classes
+ */
+export interface IEmptyClient {}
+
+export interface ISigningClientProvider<T> {
+  getSigningClient(contractAddr: string): T;
+}
+
+export interface IQueryClientProvider<T> {
+  getQueryClient(contractAddr: string): T;
+}
+
+export interface IMessageComposerProvider<T> {
+  getMessageComposer(contractAddr: string): T;
+}
+
+export class ContractBase<
+  TSign = IEmptyClient,
+  TQuery = IEmptyClient,
+  TMsgComposer = IEmptyClient
+> {
+  constructor(
+    protected address: string | undefined,
+    protected cosmWasmClient: CosmWasmClient | undefined,
+    protected signingCosmWasmClient: SigningCosmWasmClient | undefined,
+    private TSign?: new (
+      client: SigningCosmWasmClient,
+      sender: string,
+      contractAddress: string
+    ) => TSign,
+    private TQuery?: new (
+      client: CosmWasmClient,
+      contractAddress: string
+    ) => TQuery,
+    private TMsgComposer?: new (
+      sender: string,
+      contractAddress: string
+    ) => TMsgComposer
+  ) {}
+
+  public getSigningClient(contractAddr: string): TSign {
+    if (!this.signingCosmWasmClient) throw new Error(NO_SINGING_ERROR_MESSAGE);
+    if (!this.address) throw new Error(NO_ADDRESS_ERROR_MESSAGE);
+    if (!this.TSign) throw new Error(NO_SIGNING_CLIENT_ERROR_MESSAGE);
+    return new this.TSign(
+      this.signingCosmWasmClient,
+      this.address,
+      contractAddr
+    );
+  }
+
+  public getQueryClient(contractAddr: string): TQuery {
+    if (!this.cosmWasmClient) throw new Error(NO_COSMWASW_CLIENT_ERROR_MESSAGE);
+    if (!this.TQuery) throw new Error(NO_QUERY_CLIENT_ERROR_MESSAGE);
+    return new this.TQuery(this.cosmWasmClient, contractAddr);
+  }
+
+  public getMessageComposer(contractAddr: string): TMsgComposer {
+    if (!this.address) throw new Error(NO_ADDRESS_ERROR_MESSAGE);
+    if (!this.TMsgComposer) throw new Error(NO_MESSAGE_COMPOSER_ERROR_MESSAGE);
+    return new this.TMsgComposer(this.address, contractAddr);
+  }
+}
+`;