@cosmwasm/ts-codegen 0.35.6 → 1.0.0

package/{src/commands/install.ts → esm/commands/install.js}

@@ -7,42 +7,35 @@ import { prompt } from '../utils/prompt';
 import { parse } from 'parse-package-name';
 import { tmpdir } from 'os';
 import { readFileSync, writeFileSync } from 'fs';
-
 const TMPDIR = tmpdir();
-const rnd = () =>
-    Math.random().toString(36).substring(2, 15) +
+const rnd = () => Math.random().toString(36).substring(2, 15) +
     Math.random().toString(36).substring(2, 15);
-
 const getPackages = (names) => {
     return names.map(pkg => {
         const { name, version } = parse(pkg);
-        return `${name}@${version}`
+        return `${name}@${version}`;
     }).join(' ');
 };
-
 export default async (argv) => {
-
     // don't prompt if we got this...
     if (argv._.length) {
         argv.pkg = argv._;
     }
-
     // current dir/package
     const cur = process.cwd();
     let thisPackage;
     try {
         thisPackage = JSON.parse(readFileSync(join(cur, 'package.json'), 'utf-8'));
-    } catch (e) {
+    }
+    catch (e) {
         throw new Error('make sure you are inside of a telescope package!');
     }
-
     // what are we installing?
     let { pkg } = await prompt([
         {
             type: 'checkbox',
             name: 'pkg',
-            message:
-                'which chain contracts do you want to support?',
+            message: 'which chain contracts do you want to support?',
             choices: [
                 'stargaze-base-factory',
                 'stargaze-base-minter',
@@ -58,39 +51,37 @@ export default async (argv) => {
                 return {
                     name,
                     value: `@cosmjson/${name}`
-                }
+                };
             })
         }
     ], argv);
-
     // install
-    if (!Array.isArray(pkg)) pkg = [pkg];
+    if (!Array.isArray(pkg))
+        pkg = [pkg];
     const tmp = join(TMPDIR, rnd());
     mkdirp(tmp);
     process.chdir(tmp);
     exec(`npm install ${getPackages(pkg)} --production --prefix ./smart-contracts`);
-
     // protos
     const pkgs = glob('./smart-contracts/**/package.json');
     const cmds = pkgs
-        .filter((f) => { return f !== './smart-contracts/package.json' })
+        .filter((f) => { return f !== './smart-contracts/package.json'; })
         .map((f) => resolve(join(tmp, f)))
         .map((conf) => {
-            const extDir = dirname(conf);
-            const dir = extDir.split('node_modules/')[1];
-            const dst = basename(dir);
-
-            const files = glob(`${extDir}/**/*`, { nodir: true });
-            files.forEach(f => {
-                if (extname(f) === '.json'
-                    || f === 'package.json'
-                    || /license/i.test(f)
-                    || /readme/i.test(f)) return;
-                rimraf(f);
-            });
-            return [extDir, resolve(join(cur, 'contracts', dst)), dir];
+        const extDir = dirname(conf);
+        const dir = extDir.split('node_modules/')[1];
+        const dst = basename(dir);
+        const files = glob(`${extDir}/**/*`, { nodir: true });
+        files.forEach(f => {
+            if (extname(f) === '.json'
+                || f === 'package.json'
+                || /license/i.test(f)
+                || /readme/i.test(f))
+                return;
+            rimraf(f);
         });
-
+        return [extDir, resolve(join(cur, 'contracts', dst)), dir];
+    });
     // move protos 
     for (const [src, dst, pkg] of cmds) {
         rimraf(dst);
@@ -98,7 +89,6 @@ export default async (argv) => {
         mkdirp(dirname(dst));
         exec(`mv ${src} ${dst}`);
     }
-
     // package
     const packageInfo = JSON.parse(readFileSync('./smart-contracts/package.json', 'utf-8'));
     const deps = packageInfo.dependencies ?? {};
@@ -107,11 +97,8 @@ export default async (argv) => {
         ...thisPackage.devDependencies,
         ...deps
     };
-
     thisPackage.devDependencies = Object.fromEntries(Object.entries(thisPackage.devDependencies).sort());
-
     writeFileSync(join(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));
-
     // cleanup
     rimraf(tmp);
     process.chdir(cur);

package/esm/file.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { prompt } from './utils/prompt';
+import { cli } from './cli';
+import { readFileSync } from 'fs';
+const argv = require('minimist')(process.argv.slice(2));
+const question = [
+    {
+        _: true,
+        type: 'string',
+        name: 'file',
+        message: 'file'
+    }
+];
+(async () => {
+    const { file } = await prompt(question, argv);
+    const argvv = JSON.parse(readFileSync(file, 'utf-8'));
+    await cli(argvv);
+})();

package/esm/generators/client.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 * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext } from "wasm-ast-types";
+export default async (name, contractInfo, outPath, tsClientOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        client: tsClientOptions ?? {}
+    });
+    // const options = context.options.client;
+    const localname = pascal(name) + '.client.ts';
+    const TypesFile = pascal(name) + '.types';
+    const QueryMsg = findQueryMsg(schemas);
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    let Client = null;
+    let Instance = null;
+    let QueryClient = null;
+    let ReadOnlyInstance = null;
+    const body = [];
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    // query messages
+    if (QueryMsg) {
+        QueryClient = pascal(`${name}QueryClient`);
+        ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+        body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+        body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
+    }
+    // execute messages
+    if (ExecuteMsg) {
+        const children = getMessageProperties(ExecuteMsg);
+        if (children.length > 0) {
+            Client = pascal(`${name}Client`);
+            Instance = pascal(`${name}Interface`);
+            body.push(w.createExecuteInterface(context, Instance, context.options.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
+            body.push(w.createExecuteClass(context, Client, Instance, context.options.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header + generate(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    mkdirp(outPath);
+    writeFileSync(join(outPath, localname), code);
+    return [
+        {
+            type: 'client',
+            contract: name,
+            localname,
+            filename: join(outPath, localname),
+        }
+    ];
+};

package/esm/generators/create-helpers.js

@@ -0,0 +1,36 @@
+import { join, dirname, basename, extname } from "path";
+import { sync as mkdirp } from "mkdirp";
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+import { contractContextBase, contractContextBaseShortHandCtor, 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, varname) => {
+    const outFile = join(outPath, file);
+    mkdirp(dirname(outFile));
+    writeContentToFile(outPath, header + content, outFile);
+    return {
+        type: "plugin",
+        pluginType: "helper",
+        contract: varname ?? basename(file, extname(file)),
+        localname: file,
+        filename: outFile,
+    };
+};
+export const createHelpers = (input, builderContext) => {
+    const files = [];
+    if (input.options?.useContractsHooks?.enabled &&
+        Object.keys(builderContext.providers)?.length) {
+        const useShorthandCtor = input.options?.useShorthandCtor;
+        files.push(write(input.outPath, "contractContextBase.ts", useShorthandCtor
+            ? contractContextBaseShortHandCtor
+            : contractContextBase));
+        files.push(write(input.outPath, "contracts-context.tsx", contractsContextTSX, "contractsContext"));
+    }
+    return files;
+};

package/esm/generators/message-composer.js

@@ -0,0 +1,55 @@
+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 * 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 { RenderContext } from "wasm-ast-types";
+export default async (name, contractInfo, outPath, messageComposerOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        messageComposer: messageComposerOptions ?? {}
+    });
+    // const options = context.options.messageComposer;
+    const localname = pascal(name) + '.message-composer.ts';
+    const TypesFile = pascal(name) + '.types';
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    const body = [];
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    // execute messages
+    if (ExecuteMsg) {
+        const children = getMessageProperties(ExecuteMsg);
+        if (children.length > 0) {
+            const TheClass = pascal(`${name}MessageComposer`);
+            const Interface = pascal(`${name}Message`);
+            body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
+            body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header + generate(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    mkdirp(outPath);
+    writeFileSync(join(outPath, localname), code);
+    return [
+        {
+            type: 'message-composer',
+            contract: name,
+            localname,
+            filename: join(outPath, localname),
+        }
+    ];
+};

package/esm/generators/msg-builder.js

@@ -0,0 +1,58 @@
+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 * as t from "@babel/types";
+import { writeFileSync } from "fs";
+import generate from "@babel/generator";
+import { getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext } from 'wasm-ast-types';
+export default async (name, contractInfo, outPath, messageBuilderOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        messageBuilder: messageBuilderOptions ?? {},
+    });
+    const localname = pascal(name) + ".message-builder.ts";
+    const TypesFile = pascal(name) + ".types";
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    const body = [];
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    body.push(w.importStmt(["CamelCasedProperties"], "type-fest"));
+    // execute messages
+    if (ExecuteMsg) {
+        const children = getMessageProperties(ExecuteMsg);
+        if (children.length > 0) {
+            const className = pascal(`${name}ExecuteMsgBuilder`);
+            body.push(w.createMessageBuilderClass(context, className, ExecuteMsg));
+        }
+    }
+    const QueryMsg = findQueryMsg(schemas);
+    // query messages
+    if (QueryMsg) {
+        const children = getMessageProperties(QueryMsg);
+        if (children.length > 0) {
+            const className = pascal(`${name}QueryMsgBuilder`);
+            body.push(w.createMessageBuilderClass(context, className, QueryMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty("Coin")) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    // @ts-ignore
+    const code = header + generate(t.program([...imports, ...body])).code;
+    mkdirp(outPath);
+    writeFileSync(join(outPath, localname), code);
+    return [
+        {
+            type: "message-builder",
+            contract: name,
+            localname,
+            filename: join(outPath, localname),
+        },
+    ];
+};

package/esm/generators/react-query.js

@@ -0,0 +1,76 @@
+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 } from '../utils';
+import { getMessageProperties } from "wasm-ast-types";
+export default async (contractName, contractInfo, outPath, reactQueryOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        reactQuery: reactQueryOptions ?? {}
+    });
+    const options = context.options.reactQuery;
+    const localname = pascal(`${contractName}`) + '.react-query.ts';
+    const ContractFile = pascal(`${contractName}`) + '.client';
+    const TypesFile = pascal(`${contractName}`) + '.types';
+    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 clientImports = [];
+    QueryMsg && clientImports.push(QueryClient);
+    // check that there are commands within the exec msg
+    const shouldGenerateMutationHooks = ExecuteMsg && options?.version === 'v4' && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
+    if (shouldGenerateMutationHooks) {
+        clientImports.push(ExecuteClient);
+    }
+    // general contract imports
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    // client imports
+    body.push(w.importStmt(clientImports, `./${ContractFile}`));
+    // 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
+        }));
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header + generate(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    mkdirp(outPath);
+    writeFileSync(join(outPath, localname), code);
+    return [
+        {
+            type: 'react-query',
+            contract: contractName,
+            localname,
+            filename: join(outPath, localname),
+        }
+    ];
+};

package/esm/generators/recoil.js

@@ -0,0 +1,58 @@
+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 * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findQueryMsg } from "../utils";
+import { RenderContext } from "wasm-ast-types";
+export default async (name, contractInfo, outPath, recoilOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        recoil: recoilOptions ?? {}
+    });
+    const options = context.options.recoil;
+    const localname = pascal(name) + '.recoil.ts';
+    const ContractFile = pascal(name) + '.client';
+    const TypesFile = pascal(name) + '.types';
+    const QueryMsg = findQueryMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    let QueryClient = null;
+    let ReadOnlyInstance = null;
+    const body = [];
+    body.push(w.importStmt(['cosmWasmClient'], './chain'));
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    // query messages
+    if (QueryMsg) {
+        QueryClient = pascal(`${name}QueryClient`);
+        ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+        body.push(w.importStmt([QueryClient], `./${ContractFile}`));
+        body.push(w.createRecoilQueryClientType());
+        body.push(w.createRecoilQueryClient(context, name, QueryClient));
+        const selectors = w.createRecoilSelectors(context, name, QueryClient, QueryMsg);
+        body.push(...selectors);
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header + generate(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    mkdirp(outPath);
+    writeFileSync(join(outPath, localname), code);
+    return [
+        {
+            type: 'recoil',
+            contract: name,
+            localname,
+            filename: join(outPath, localname),
+        }
+    ];
+};

package/esm/generators/types.js

@@ -0,0 +1,58 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { clean } from "../utils/clean";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext } from "wasm-ast-types";
+export default async (name, contractInfo, outPath, tsTypesOptions) => {
+    const { schemas } = contractInfo;
+    const context = new RenderContext(contractInfo, {
+        types: tsTypesOptions ?? {}
+    });
+    const options = context.options.types;
+    const localname = pascal(name) + '.types.ts';
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    const body = [];
+    // TYPES
+    Object.values(typeHash).forEach((type) => {
+        body.push(clean(type));
+    });
+    // alias the ExecuteMsg (deprecated option)
+    if (options.aliasExecuteMsg && ExecuteMsg) {
+        body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+    }
+    function addEntryPointAlias(msgName) {
+        body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}${msgName}`), null, t.tsTypeReference(t.identifier(msgName)))));
+    }
+    if (options.aliasEntryPoints) {
+        if (ExecuteMsg) {
+            addEntryPointAlias('ExecuteMsg');
+        }
+        if (findQueryMsg(schemas)) {
+            addEntryPointAlias('QueryMsg');
+        }
+    }
+    const imports = context.getImports();
+    const code = header + generate(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    mkdirp(outPath);
+    const filename = join(outPath, localname);
+    writeFileSync(filename, code);
+    return [
+        {
+            type: 'type',
+            contract: name,
+            localname,
+            filename,
+        }
+    ];
+};

package/{src/index.ts → esm/index.js}

@@ -1,17 +1,14 @@
-import { TSBuilder, TSBuilderInput } from './builder';
-
+import { TSBuilder } from './builder';
 export { default as generateTypes } from './generators/types';
 export { default as generateClient } from './generators/client';
 export { default as generateMessageComposer } from './generators/message-composer';
 export { default as generateReactQuery } from './generators/react-query';
 export { default as generateRecoil } from './generators/recoil';
-
 export * from './utils';
 export * from './builder';
 export * from './bundler';
 export * from './plugins';
-
-export default async (input: TSBuilderInput) => {
+export default async (input) => {
     const builder = new TSBuilder(input);
     await builder.build();
-};
+};

package/esm/plugins/client.js

@@ -0,0 +1,59 @@
+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, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        const { enabled } = this.option.client;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const localname = pascal(name) + ".client.ts";
+        const TypesFile = pascal(name) + ".types";
+        const QueryMsg = findQueryMsg(schemas);
+        const ExecuteMsg = findExecuteMsg(schemas);
+        const typeHash = await findAndParseTypes(schemas);
+        let Client = null;
+        let Instance = null;
+        let QueryClient = null;
+        let ReadOnlyInstance = null;
+        const body = [];
+        body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+        // query messages
+        if (QueryMsg) {
+            QueryClient = pascal(`${name}QueryClient`);
+            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
+        if (ExecuteMsg) {
+            const children = getMessageProperties(ExecuteMsg);
+            if (children.length > 0) {
+                Client = pascal(`${name}Client`);
+                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")) {
+            // @ts-ignore
+            delete context.utils.Coin;
+        }
+        return [
+            {
+                type: TYPE,
+                localname,
+                body,
+            },
+        ];
+    }
+}