@cosmwasm/ts-codegen 0.5.8 → 0.7.0

package/main/utils/schemas.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readSchemas = exports.getDefinitionSchema = exports.findQueryMsg = exports.findExecuteMsg = exports.findAndParseTypes = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _glob = require("glob");
+
+var _fs = require("fs");
+
+var _cleanse = require("./cleanse");
+
+var _jsonSchemaToTypescript = require("json-schema-to-typescript");
+
+var _parse = require("./parse");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var readSchemas = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(_ref) {
+    var schemaDir, argv, _ref$clean, clean, fn, files, schemas;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            schemaDir = _ref.schemaDir, argv = _ref.argv, _ref$clean = _ref.clean, clean = _ref$clean === void 0 ? true : _ref$clean;
+            fn = clean ? _cleanse.cleanse : function (str) {
+              return str;
+            };
+            files = (0, _glob.sync)(schemaDir + '/**/*.json');
+            schemas = files.map(function (file) {
+              return JSON.parse((0, _fs.readFileSync)(file, 'utf-8'));
+            });
+
+            if (!argv.packed) {
+              _context.next = 8;
+              break;
+            }
+
+            if (!(schemas.length !== 1)) {
+              _context.next = 7;
+              break;
+            }
+
+            throw new Error('packed option only supports one file');
+
+          case 7:
+            return _context.abrupt("return", Object.values(fn(schemas[0])));
+
+          case 8:
+            return _context.abrupt("return", fn(schemas));
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function readSchemas(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+exports.readSchemas = readSchemas;
+
+var findQueryMsg = function findQueryMsg(schemas) {
+  var QueryMsg = schemas.find(function (schema) {
+    return schema.title === 'QueryMsg';
+  });
+  return QueryMsg;
+};
+
+exports.findQueryMsg = findQueryMsg;
+
+var findExecuteMsg = function findExecuteMsg(schemas) {
+  var ExecuteMsg = schemas.find(function (schema) {
+    return schema.title === 'ExecuteMsg' || schema.title === 'ExecuteMsg_for_Empty' || // if cleanse is used, this is never
+    schema.title === 'ExecuteMsgForEmpty';
+  });
+  return ExecuteMsg;
+};
+
+exports.findExecuteMsg = findExecuteMsg;
+
+var findAndParseTypes = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(schemas) {
+    var Types, allTypes, typ, _i, _Object$keys, key, result, typeHash;
+
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            Types = schemas;
+            allTypes = [];
+            _context2.t0 = _regenerator["default"].keys(Types);
+
+          case 3:
+            if ((_context2.t1 = _context2.t0()).done) {
+              _context2.next = 12;
+              break;
+            }
+
+            typ = _context2.t1.value;
+
+            if (Types[typ].definitions) {
+              for (_i = 0, _Object$keys = Object.keys(Types[typ].definitions); _i < _Object$keys.length; _i++) {
+                key = _Object$keys[_i];
+                // set title
+                Types[typ].definitions[key].title = key;
+              }
+            }
+
+            _context2.next = 8;
+            return (0, _jsonSchemaToTypescript.compile)(Types[typ], Types[typ].title);
+
+          case 8:
+            result = _context2.sent;
+            allTypes.push(result);
+            _context2.next = 3;
+            break;
+
+          case 12:
+            typeHash = (0, _parse.parser)(allTypes);
+            return _context2.abrupt("return", typeHash);
+
+          case 14:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function findAndParseTypes(_x2) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+exports.findAndParseTypes = findAndParseTypes;
+
+var getDefinitionSchema = function getDefinitionSchema(schemas) {
+  var aggregateSchema = {
+    definitions: {//
+    }
+  };
+  schemas.forEach(function (schema) {
+    schema.definitions = schema.definitions || {};
+    aggregateSchema.definitions = _objectSpread(_objectSpread({}, aggregateSchema.definitions), schema.definitions);
+  });
+  return aggregateSchema;
+};
+
+exports.getDefinitionSchema = getDefinitionSchema;

package/module/cli.js

@@ -1,4 +1,4 @@
-import { prompt } from './prompt';
+import { prompt } from './utils/prompt';
 import { Commands as commands } from './cmds';
 const question = [{
   _: true,

package/module/cmds.js

@@ -1,10 +1,8 @@
-import _boilerplate from './commands/boilerplate';
 import _from_partial from './commands/from-partial';
 import _generate from './commands/generate';
 import _react_query from './commands/react-query';
 import _recoil from './commands/recoil';
 const Commands = {};
-Commands['boilerplate'] = _boilerplate;
 Commands['from-partial'] = _from_partial;
 Commands['generate'] = _generate;
 Commands['react-query'] = _react_query;

package/module/commands/from-partial.js

@@ -1,5 +1,5 @@
-import { prompt } from '../prompt';
-import fromPartial from '../from-partial';
+import { prompt } from '../utils/prompt';
+import fromPartial from '../generators/from-partial';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -25,7 +25,7 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/commands/generate.js

@@ -1,5 +1,5 @@
-import { prompt } from '../prompt';
-import cosmscript from '../generate';
+import { prompt } from '../utils/prompt';
+import tsClient from '../generators/ts-client';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -25,9 +25,9 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });
-  await cosmscript(name, schemas, out);
+  await tsClient(name, schemas, out);
 });

package/module/commands/react-query.js

@@ -1,7 +1,7 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 const _excluded = ["schema", "out", "name"];
-import { prompt } from '../prompt';
-import reactQuery from '../react-query';
+import { prompt } from '../utils/prompt';
+import reactQuery from '../generators/react-query';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -31,6 +31,11 @@ export default (async argv => {
     name: 'v4',
     message: 'Use react-query v4?',
     default: false
+  }, {
+    type: 'confirm',
+    name: 'mutations',
+    message: 'Geneate useMutation hooks? Must be used with v4.',
+    default: false
   }];
 
   const _await$prompt = await prompt(questions, argv),
@@ -41,7 +46,7 @@ export default (async argv => {
   } = _await$prompt,
         options = _objectWithoutProperties(_await$prompt, _excluded);
 
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/commands/recoil.js

@@ -1,4 +1,4 @@
-import { prompt } from '../prompt';
+import { prompt } from '../utils/prompt';
 import recoil from '../recoil';
 import { readSchemas } from '../utils';
 export default (async argv => {
@@ -25,7 +25,7 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/file.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { prompt } from './prompt';
+import { prompt } from './utils/prompt';
 import { cli } from './cli';
 import { readFileSync } from 'fs';
 

package/module/{from-partial.js → generators/from-partial.js}

@@ -1,5 +1,5 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
@@ -7,7 +7,8 @@ import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
 import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg } from "./utils";
+import { findAndParseTypes, findExecuteMsg, getDefinitionSchema } from "../utils";
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const FromPartialFile = pascal(`${name}Contract`) + '.from-partial.ts';
   const Contract = pascal(`${name}Contract`) + '.ts';
@@ -22,7 +23,8 @@ export default (async (name, schemas, outPath) => {
     body.push(w.importStmt(['Coin'], '@cosmjs/amino'));
   }
 
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // execute messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // execute messages
 
   if (ExecuteMsg) {
     const children = getMessageProperties(ExecuteMsg);
@@ -30,8 +32,8 @@ export default (async (name, schemas, outPath) => {
     if (children.length > 0) {
       const TheClass = pascal(`${name}MessageComposer`);
       const Interface = pascal(`${name}Message`);
-      body.push(w.createFromPartialInterface(Interface, ExecuteMsg));
-      body.push(w.createFromPartialClass(TheClass, Interface, ExecuteMsg));
+      body.push(w.createFromPartialInterface(context, Interface, ExecuteMsg));
+      body.push(w.createFromPartialClass(context, TheClass, Interface, ExecuteMsg));
     }
   }
 

package/module/generators/react-query.js

@@ -0,0 +1,67 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import { RenderContext } from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
+import { getMessageProperties } from "wasm-ast-types";
+import { cosmjsAminoImportStatements } from '../utils/imports';
+export default (async (contractName, schemas, outPath, reactQueryOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    reactQuery: reactQueryOptions ?? {}
+  });
+  const options = context.options.reactQuery;
+  const ReactQueryFile = pascal(`${contractName}Contract`) + '.react-query.ts';
+  const Contract = pascal(`${contractName}Contract`);
+  const QueryMsg = findQueryMsg(schemas);
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  const ExecuteClient = pascal(`${contractName}Client`);
+  const QueryClient = pascal(`${contractName}QueryClient`);
+  const body = [];
+  const reactQueryImports = ['useQuery', 'UseQueryOptions'];
+  const clientImports = [];
+  QueryMsg && clientImports.push(QueryClient); // check that there are commands within the exec msg
+
+  const shouldGenerateMutationHooks = ExecuteMsg && options?.v4 && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
+
+  if (shouldGenerateMutationHooks) {
+    body.push(w.importStmt(['ExecuteResult'], '@cosmjs/cosmwasm-stargate'));
+    body.push(cosmjsAminoImportStatements(typeHash));
+    reactQueryImports.push('useMutation', 'UseMutationOptions');
+    clientImports.push(ExecuteClient);
+  } // react-query imports
+
+
+  body.push(w.importStmt(reactQueryImports, options?.v4 ? '@tanstack/react-query' : 'react-query')); // general contract imports
+
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`)); // client imports
+
+  body.push(w.importStmt(clientImports, `./${Contract}`)); // query messages
+
+  if (QueryMsg) {
+    [].push.apply(body, w.createReactQueryHooks({
+      context,
+      queryMsg: QueryMsg,
+      contractName: contractName,
+      QueryClient
+    }));
+  }
+
+  if (shouldGenerateMutationHooks) {
+    [].push.apply(body, w.createReactQueryMutationHooks({
+      context,
+      execMsg: ExecuteMsg,
+      contractName: contractName,
+      ExecuteClient
+    }));
+  }
+
+  const code = header + generate(t.program(body)).code;
+  mkdirp(outPath);
+  writeFileSync(join(outPath, ReactQueryFile), code);
+});

package/module/{recoil.js → generators/recoil.js}

@@ -1,12 +1,13 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { findAndParseTypes, findQueryMsg } from "./utils";
+import { findAndParseTypes, findQueryMsg, getDefinitionSchema } from "../utils";
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const RecoilFile = pascal(`${name}Contract`) + '.recoil.ts';
   const Contract = pascal(`${name}Contract`) + '.ts';
@@ -17,15 +18,16 @@ export default (async (name, schemas, outPath) => {
   const body = [];
   body.push(w.importStmt(['selectorFamily'], 'recoil'));
   body.push(w.importStmt(['cosmWasmClient'], './chain'));
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // query messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
     ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
     body.push(w.importStmt([QueryClient], `./${Contract}`));
     body.push(w.createRecoilQueryClientType());
-    body.push(w.createRecoilQueryClient(name, QueryClient));
-    [].push.apply(body, w.createRecoilSelectors(name, QueryClient, QueryMsg));
+    body.push(w.createRecoilQueryClient(context, name, QueryClient));
+    [].push.apply(body, w.createRecoilSelectors(context, name, QueryClient, QueryMsg));
   }
 
   const code = header + generate(t.program(body)).code;

package/module/{generate.js → generators/ts-client.js}

@@ -1,14 +1,16 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { clean } from "./clean";
+import { clean } from "../utils/clean";
 import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from "./utils";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
+import { cosmjsAminoImportStatements } from '../utils/imports';
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const Contract = pascal(`${name}Contract`) + '.ts';
   const QueryMsg = findQueryMsg(schemas);
@@ -20,23 +22,20 @@ export default (async (name, schemas, outPath) => {
   let ReadOnlyInstance = null;
   const body = [];
   body.push(w.importStmt(['CosmWasmClient', 'ExecuteResult', 'SigningCosmWasmClient'], '@cosmjs/cosmwasm-stargate'));
-
-  if (typeHash.hasOwnProperty('Coin')) {
-    body.push(w.importStmt(['StdFee'], '@cosmjs/amino'));
-  } else {
-    body.push(w.importStmt(['Coin', 'StdFee'], '@cosmjs/amino'));
-  } // TYPES
-
+  body.push(cosmjsAminoImportStatements(typeHash)); // TYPES
 
   Object.values(typeHash).forEach(type => {
     body.push(clean(type));
-  }); // query messages
+  }); // alias the ExecuteMsg
+
+  ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
     ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
-    body.push(w.createQueryInterface(ReadOnlyInstance, QueryMsg));
-    body.push(w.createQueryClass(QueryClient, ReadOnlyInstance, QueryMsg));
+    body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+    body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
   } // execute messages
 
 
@@ -46,8 +45,8 @@ export default (async (name, schemas, outPath) => {
     if (children.length > 0) {
       Client = pascal(`${name}Client`);
       Instance = pascal(`${name}Interface`);
-      body.push(w.createExecuteInterface(Instance, ReadOnlyInstance, ExecuteMsg));
-      body.push(w.createExecuteClass(Client, Instance, QueryClient, ExecuteMsg));
+      body.push(w.createExecuteInterface(context, Instance, ReadOnlyInstance, ExecuteMsg));
+      body.push(w.createExecuteClass(context, Client, Instance, QueryClient, ExecuteMsg));
     }
   }
 

package/module/index.js

@@ -1,5 +1,6 @@
-export { default as generate } from './generate';
-export { default as fromPartial } from './from-partial';
-export { default as reactQuery } from './react-query';
-export { default as recoil } from './recoil';
-export * from './utils';
+export { default as tsClient } from './generators/ts-client';
+export { default as fromPartial } from './generators/from-partial';
+export { default as reactQuery } from './generators/react-query';
+export { default as recoil } from './generators/recoil';
+export * from './utils';
+export * from './utils/imports';

package/module/{header.js → utils/header.js}

@@ -1,4 +1,4 @@
-import pkg from '../package.json';
+import pkg from '../../package.json';
 const version = process.env.NODE_ENV === 'test' ? 'latest' : pkg.version;
 export const header = `/**
 * This file was automatically generated by ${pkg.name}@${version}.

package/module/utils/imports.js

@@ -0,0 +1,10 @@
+import * as w from 'wasm-ast-types';
+export const cosmjsAminoImportStatements = typeHash => {
+  const cosmjsImports = ['StdFee']; // If the coin is not provided by the generation already, import it from cosmjs
+
+  if (!typeHash.hasOwnProperty('Coin')) {
+    cosmjsImports.unshift('Coin');
+  }
+
+  return w.importStmt(cosmjsImports, '@cosmjs/amino');
+};

package/module/utils/index.js

@@ -0,0 +1 @@
+export * from './schemas';

package/module/{utils.js → utils/schemas.js}

@@ -1,9 +1,15 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
 import { sync as glob } from 'glob';
 import { readFileSync } from 'fs';
 import { cleanse } from './cleanse';
 import { compile } from 'json-schema-to-typescript';
-import { parser } from "./parse";
-export const readSchemas = ({
+import { parser } from './parse';
+export const readSchemas = async ({
   schemaDir,
   argv,
   clean = true
@@ -49,4 +55,15 @@ export const findAndParseTypes = async schemas => {
 
   const typeHash = parser(allTypes);
   return typeHash;
+};
+export const getDefinitionSchema = schemas => {
+  const aggregateSchema = {
+    definitions: {//
+    }
+  };
+  schemas.forEach(schema => {
+    schema.definitions = schema.definitions || {};
+    aggregateSchema.definitions = _objectSpread(_objectSpread({}, aggregateSchema.definitions), schema.definitions);
+  });
+  return aggregateSchema;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.5.8",
+  "version": "0.7.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",
@@ -47,50 +47,50 @@
     "url": "https://github.com/cosmwasm/ts-codegen/issues"
   },
   "devDependencies": {
-    "@babel/cli": "7.17.10",
-    "@babel/eslint-parser": "^7.18.2",
-    "@babel/node": "^7.18.5",
-    "@types/jest": "^28.1.2",
+    "@babel/cli": "7.18.10",
+    "@babel/eslint-parser": "^7.18.9",
+    "@babel/node": "^7.18.10",
+    "@types/jest": "^28.1.6",
     "ast-stringify": "0.1.0",
     "babel-core": "7.0.0-bridge.0",
-    "babel-jest": "28.1.1",
+    "babel-jest": "28.1.3",
     "babel-watch": "^7.0.0",
     "cosmwasm": "1.1.1",
     "cross-env": "^7.0.2",
-    "eslint": "8.17.0",
+    "eslint": "8.21.0",
     "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^28.1.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^28.1.3",
     "jest-in-case": "^1.0.2",
     "prettier": "^2.7.1",
     "regenerator-runtime": "^0.13.7",
-    "ts-jest": "^28.0.5",
+    "ts-jest": "^28.0.7",
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@babel/core": "7.18.5",
-    "@babel/generator": "7.18.2",
-    "@babel/parser": "7.18.5",
-    "@babel/plugin-proposal-class-properties": "7.17.12",
-    "@babel/plugin-proposal-export-default-from": "7.17.12",
-    "@babel/plugin-proposal-object-rest-spread": "7.18.0",
-    "@babel/plugin-transform-runtime": "7.18.5",
-    "@babel/preset-env": "7.18.2",
-    "@babel/preset-typescript": "^7.17.12",
-    "@babel/runtime": "^7.18.3",
-    "@babel/traverse": "7.18.5",
-    "@babel/types": "7.18.4",
+    "@babel/core": "7.18.10",
+    "@babel/generator": "7.18.12",
+    "@babel/parser": "7.18.11",
+    "@babel/plugin-proposal-class-properties": "7.18.6",
+    "@babel/plugin-proposal-export-default-from": "7.18.10",
+    "@babel/plugin-proposal-object-rest-spread": "7.18.9",
+    "@babel/plugin-transform-runtime": "7.18.10",
+    "@babel/preset-env": "7.18.10",
+    "@babel/preset-typescript": "^7.18.6",
+    "@babel/runtime": "^7.18.9",
+    "@babel/traverse": "7.18.11",
+    "@babel/types": "7.18.10",
     "case": "1.6.3",
     "dargs": "7.0.0",
     "fuzzy": "0.1.3",
     "glob": "8.0.3",
     "inquirerer": "0.1.3",
-    "json-schema-to-typescript": "10.1.5",
+    "json-schema-to-typescript": "11.0.1",
     "long": "^5.2.0",
     "minimist": "1.2.6",
     "mkdirp": "1.0.4",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.4.3"
+    "wasm-ast-types": "^0.6.0"
   },
-  "gitHead": "c5fc4992d9da5f1c9da1f2c34469994dee7801df"
+  "gitHead": "51e6e530adc95d8118606379848080dd9bc3c25a"
 }

package/types/cleanse.d.ts

@@ -0,0 +1 @@
+export declare const cleanse: (obj: any) => any;

package/types/imports.d.ts

@@ -0,0 +1 @@
+export declare const cosmjsAminoImportStatements: (typeHash: any) => any;