@cosmwasm/ts-codegen 0.30.1 → 0.31.0

package/main/plugins/provider.js

@@ -0,0 +1,170 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetLocalNameByContractName = exports.GetLocalBaseNameByContractName = exports.ContractsContextProviderPlugin = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _case = require("case");
+
+var w = _interopRequireWildcard(require("wasm-ast-types"));
+
+var _pluginBase = require("./plugin-base");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var GetLocalNameByContractName = function GetLocalNameByContractName(name) {
+  return "".concat((0, _case.pascal)(name), ".provider.ts");
+};
+
+exports.GetLocalNameByContractName = GetLocalNameByContractName;
+
+var GetLocalBaseNameByContractName = function GetLocalBaseNameByContractName(name) {
+  return "".concat((0, _case.pascal)(name), ".provider");
+};
+
+exports.GetLocalBaseNameByContractName = GetLocalBaseNameByContractName;
+
+var ContractsContextProviderPlugin = /*#__PURE__*/function (_BuilderPluginBase) {
+  (0, _inherits2["default"])(ContractsContextProviderPlugin, _BuilderPluginBase);
+
+  var _super = _createSuper(ContractsContextProviderPlugin);
+
+  function ContractsContextProviderPlugin(opt) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, ContractsContextProviderPlugin);
+    _this = _super.call(this, opt);
+    _this.utils = {
+      ContractBase: "__contractContextBase__",
+      IContractConstructor: "__contractContextBase__",
+      IEmptyClient: "__contractContextBase__"
+    };
+    return _this;
+  }
+
+  (0, _createClass2["default"])(ContractsContextProviderPlugin, [{
+    key: "initContext",
+    value: function initContext(contract, options) {
+      return new w.RenderContext(contract, options, this.builder.builderContext);
+    }
+  }, {
+    key: "doRender",
+    value: function () {
+      var _doRender = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, context) {
+        var _this$option, _this$option$useContr, _Object$keys;
+
+        var providerInfo, localname, needEmptyClientType, clientFile, clientClasses, body, signClientProviderInfo, queryClientProviderInfo, messageComposerProviderInfo;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if ((_this$option = this.option) !== null && _this$option !== void 0 && (_this$option$useContr = _this$option.useContracts) !== null && _this$option$useContr !== void 0 && _this$option$useContr.enabled) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 2:
+                providerInfo = context.getProviderInfos()[name];
+
+                if ((_Object$keys = Object.keys(providerInfo)) !== null && _Object$keys !== void 0 && _Object$keys.length) {
+                  _context.next = 5;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 5:
+                context.addUtil("ContractBase");
+                context.addUtil("IContractConstructor");
+                localname = GetLocalNameByContractName(name);
+                needEmptyClientType = false;
+                clientFile = null;
+                clientClasses = [];
+                body = [];
+                signClientProviderInfo = providerInfo[w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE];
+
+                if (signClientProviderInfo) {
+                  clientFile = "./".concat(signClientProviderInfo.basename);
+                  clientClasses.push(signClientProviderInfo.classname);
+                } else {
+                  needEmptyClientType = true;
+                }
+
+                queryClientProviderInfo = providerInfo[w.PROVIDER_TYPES.QUERY_CLIENT_TYPE];
+
+                if (queryClientProviderInfo) {
+                  clientFile = "./".concat(queryClientProviderInfo.basename);
+                  clientClasses.push(queryClientProviderInfo.classname);
+                } else {
+                  needEmptyClientType = true;
+                }
+
+                if (clientFile) {
+                  body.push(w.importStmt(clientClasses, clientFile));
+                }
+
+                messageComposerProviderInfo = providerInfo[w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE];
+
+                if (messageComposerProviderInfo) {
+                  body.push(w.importStmt([messageComposerProviderInfo.classname], "./".concat(messageComposerProviderInfo.basename)));
+                } else {
+                  needEmptyClientType = true;
+                }
+
+                if (needEmptyClientType) {
+                  context.addUtil("IEmptyClient");
+                }
+
+                body.push(w.createProvider(name, providerInfo));
+                return _context.abrupt("return", [{
+                  type: "plugin",
+                  localname: localname,
+                  body: body
+                }]);
+
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function doRender(_x, _x2) {
+        return _doRender.apply(this, arguments);
+      }
+
+      return doRender;
+    }()
+  }]);
+  return ContractsContextProviderPlugin;
+}(_pluginBase.BuilderPluginBase);
+
+exports.ContractsContextProviderPlugin = ContractsContextProviderPlugin;

package/main/plugins/react-query.js

@@ -52,7 +52,7 @@ var ReactQueryPlugin = /*#__PURE__*/function (_BuilderPluginBase) {
   (0, _createClass2["default"])(ReactQueryPlugin, [{
     key: "initContext",
     value: function initContext(contract, options) {
-      return new w.RenderContext(contract, options);
+      return new w.RenderContext(contract, options, this.builder.builderContext);
     }
   }, {
     key: "doRender",

package/main/plugins/recoil.js

@@ -67,7 +67,7 @@ var RecoilPlugin = /*#__PURE__*/function (_BuilderPluginBase) {
   (0, _createClass2["default"])(RecoilPlugin, [{
     key: "initContext",
     value: function initContext(contract, options) {
-      return new w.RenderContext(contract, options);
+      return new w.RenderContext(contract, options, this.builder.builderContext);
     }
   }, {
     key: "doRender",

package/main/plugins/types.js

@@ -56,7 +56,7 @@ var TypesPlugin = /*#__PURE__*/function (_BuilderPluginBase) {
   (0, _createClass2["default"])(TypesPlugin, [{
     key: "initContext",
     value: function initContext(contract, options) {
-      return new _wasmAstTypes.RenderContext(contract, options);
+      return new _wasmAstTypes.RenderContext(contract, options, this.builder.builderContext);
     }
   }, {
     key: "doRender",

package/main/utils/files.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeContentToFile = exports.writeAstToFile = void 0;
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _parser = require("@babel/parser");
+
+var _mkdirp = require("mkdirp");
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var _unused = require("./unused");
+
+var _traverse = _interopRequireDefault(require("@babel/traverse"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var writeAstToFile = function writeAstToFile(outPath, program, filename) {
+  var removeUnusedImports = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var isTsDisable = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var isEslintDisable = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  var ast = t.program(program);
+  var content = (0, _generator["default"])(ast).code;
+
+  if (removeUnusedImports) {
+    var plugins = ["typescript"];
+    var newAst = (0, _parser.parse)(content, {
+      sourceType: "module",
+      plugins: plugins
+    });
+    (0, _traverse["default"])(newAst, _unused.unused);
+    var content2 = (0, _generator["default"])(newAst).code;
+    writeContentToFile(outPath, content2, filename, isTsDisable, isEslintDisable);
+  } else {
+    writeContentToFile(outPath, content, filename, isTsDisable, isEslintDisable);
+  }
+};
+
+exports.writeAstToFile = writeAstToFile;
+
+var writeContentToFile = function writeContentToFile(outPath, content, filename) {
+  var isTsDisable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var isEslintDisable = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var esLintPrefix = "";
+  var tsLintPrefix = "";
+  var 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";
+  }
+
+  var text = tsLintPrefix + esLintPrefix + content;
+  (0, _mkdirp.sync)((0, _path.dirname)(filename));
+  (0, _fs.writeFileSync)(filename, text);
+};
+
+exports.writeContentToFile = writeContentToFile;

package/main/utils/unused.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unused = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+//@ts-nocheck
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+var unused = {
+  Program: {
+    exit: function exit(path) {
+      var UnRefBindings = new Map();
+
+      for (var _i = 0, _Object$entries = Object.entries(path.scope.bindings); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+            name = _Object$entries$_i[0],
+            binding = _Object$entries$_i[1];
+
+        if (!binding.path.parentPath || binding.kind !== 'module') continue;
+        var source = binding.path.parentPath.get('source');
+        var importName = source.node.value;
+        if (!t.isStringLiteral(source)) continue;
+        var key = "".concat(importName, "(").concat(source.node.loc && source.node.loc.start.line, ")");
+
+        if (!UnRefBindings.has(key)) {
+          UnRefBindings.set(key, binding);
+        }
+
+        if (binding.referenced) {
+          UnRefBindings.set(key, null);
+        } else {
+          var 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(function (binding, key) {
+        if (binding && binding.path.parentPath) {
+          binding.path.parentPath.remove();
+        }
+      });
+    }
+  }
+};
+exports.unused = unused;

package/module/builder/builder.js

@@ -1,5 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { defaultOptions } from "wasm-ast-types";
+import { defaultOptions, BuilderContext } from "wasm-ast-types";
 import { header } from '../utils/header';
 import { join } from "path";
 import { writeFileSync } from 'fs';
@@ -17,6 +17,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 = {
   bundle: {
     enabled: true,
@@ -27,6 +30,7 @@ const defaultOpts = {
 ;
 ;
 ;
+;
 
 function getContract(contractOpt) {
   if (typeof contractOpt === 'string') {
@@ -46,7 +50,7 @@ function getContract(contractOpt) {
 
 export class TSBuilder {
   loadDefaultPlugins() {
-    [].push.apply(this.plugins, [new TypesPlugin(this.options), new ClientPlugin(this.options), new MessageComposerPlugin(this.options), new ReactQueryPlugin(this.options), new RecoilPlugin(this.options), new MsgBuilderPlugin(this.options)]);
+    [].push.apply(this.plugins, [new TypesPlugin(this.options), new ClientPlugin(this.options), new MessageComposerPlugin(this.options), new ReactQueryPlugin(this.options), new RecoilPlugin(this.options), new MsgBuilderPlugin(this.options), new ContractsContextProviderPlugin(this.options)]);
   }
 
   constructor({
@@ -63,6 +67,8 @@ export class TSBuilder {
 
     _defineProperty(this, "plugins", []);
 
+    _defineProperty(this, "builderContext", new BuilderContext());
+
     _defineProperty(this, "files", []);
 
     this.contracts = contracts;
@@ -73,6 +79,8 @@ export class TSBuilder {
     if (plugins && plugins.length) {
       [].push.apply(this.plugins, plugins);
     }
+
+    this.plugins.forEach(plugin => plugin.setBuilder(this));
   }
 
   async build() {
@@ -106,7 +114,25 @@ export class TSBuilder {
   async after() {
     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/module/generators/create-helpers.js

@@ -0,0 +1,25 @@
+import { join, dirname } from "path";
+import { sync as mkdirp } from "mkdirp";
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+import { contractContextBase, contractsContextTSX } from "../helpers";
+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, file, content) => {
+  const outFile = join(outPath, file);
+  mkdirp(dirname(outFile));
+  writeContentToFile(outPath, header + content, outFile);
+};
+
+export const createHelpers = (input, 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/module/helpers/contractContextBase.js

@@ -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);
+  }
+}
+`;

package/module/helpers/contractsContextTSX.js

@@ -0,0 +1,73 @@
+export const contractsContextTSX = `
+import React, { useEffect, useMemo, useRef, useState, useContext } from 'react';
+import {
+  CosmWasmClient,
+  SigningCosmWasmClient,
+} from '@cosmjs/cosmwasm-stargate';
+
+import { IContractsContext, getProviders } from './contractContextProviders';
+
+interface ContractsConfig {
+  address: string | undefined;
+  getCosmWasmClient: () => Promise<CosmWasmClient>;
+  getSigningCosmWasmClient: () => Promise<SigningCosmWasmClient>;
+}
+
+const ContractsContext = React.createContext<IContractsContext | null>(null);
+
+export const ContractsProvider = ({
+  children,
+  contractsConfig,
+}: {
+  children: React.ReactNode;
+  contractsConfig: ContractsConfig;
+}) => {
+  const [cosmWasmClient, setCosmWasmClient] = useState<CosmWasmClient>();
+  const [signingCosmWasmClient, setSigningCosmWasmClient] =
+    useState<SigningCosmWasmClient>();
+
+  const { address, getCosmWasmClient, getSigningCosmWasmClient } =
+    contractsConfig;
+
+  const prevAddressRef = useRef<string | undefined>(address);
+
+  const contracts: IContractsContext = useMemo(() => {
+    return getProviders(address, cosmWasmClient, signingCosmWasmClient);
+  }, [address, cosmWasmClient, signingCosmWasmClient]);
+
+  useEffect(() => {
+    const connectSigningCwClient = async () => {
+      if (address && prevAddressRef.current !== address) {
+        const signingCosmWasmClient = await getSigningCosmWasmClient();
+        setSigningCosmWasmClient(signingCosmWasmClient);
+      } else if (!address) {
+        setSigningCosmWasmClient(undefined);
+      }
+      prevAddressRef.current = address;
+    };
+    connectSigningCwClient();
+  }, [address, getSigningCosmWasmClient]);
+
+  useEffect(() => {
+    const connectCosmWasmClient = async () => {
+      const cosmWasmClient = await getCosmWasmClient();
+      setCosmWasmClient(cosmWasmClient);
+    };
+    connectCosmWasmClient();
+  }, [getCosmWasmClient]);
+
+  return (
+    <ContractsContext.Provider value={contracts}>
+      {children}
+    </ContractsContext.Provider>
+  );
+};
+
+export const useContracts = () => {
+  const contracts = useContext(ContractsContext);
+  if (contracts === null) {
+    throw new Error('useContracts must be used within a ContractsProvider');
+  }
+  return contracts;
+};
+`;

package/module/helpers/index.js

@@ -0,0 +1,2 @@
+export * from './contractContextBase';
+export * from './contractsContextTSX';

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
     }];