@cosmwasm/ts-codegen 0.30.1 → 0.31.1

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

package/src/helpers/contractsContextTSX.ts

@@ -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/src/helpers/index.ts

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

package/src/plugins/client.ts

@@ -1,22 +1,24 @@
-import { pascal } from 'case';
-import * as w from 'wasm-ast-types';
-import { findExecuteMsg, findAndParseTypes, findQueryMsg } from '../utils';
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { findExecuteMsg, findAndParseTypes, findQueryMsg } from "../utils";
 import {
   RenderContext,
   ContractInfo,
   RenderContextBase,
   getMessageProperties,
-  RenderOptions
-} from 'wasm-ast-types';
-import { BuilderFileType } from '../builder';
-import { BuilderPluginBase } from './plugin-base';
+  RenderOptions,
+} from "wasm-ast-types";
+import { BuilderFileType } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+
+export const TYPE = "client";
 
 export class ClientPlugin extends BuilderPluginBase<RenderOptions> {
   initContext(
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(
@@ -38,8 +40,8 @@ export class ClientPlugin extends BuilderPluginBase<RenderOptions> {
 
     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);
@@ -62,6 +64,13 @@ export class ClientPlugin extends BuilderPluginBase<RenderOptions> {
       body.push(
         w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg)
       );
+
+      context.addProviderInfo(
+        name,
+        w.PROVIDER_TYPES.QUERY_CLIENT_TYPE,
+        QueryClient,
+        localname
+      );
     }
 
     // execute messages
@@ -89,20 +98,27 @@ export class ClientPlugin extends BuilderPluginBase<RenderOptions> {
             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
-      }
+        body,
+      },
     ];
   }
 }

package/src/plugins/message-composer.ts

@@ -1,23 +1,25 @@
-import { pascal } from 'case';
-import * as w from 'wasm-ast-types';
-import { findAndParseTypes, findExecuteMsg } from '../utils';
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg } from "../utils";
 import {
   MessageComposerOptions,
   getMessageProperties,
   ContractInfo,
   RenderContextBase,
   RenderContext,
-  RenderOptions
-} from 'wasm-ast-types';
-import { BuilderFileType } from '../builder';
-import { BuilderPluginBase } from './plugin-base';
+  RenderOptions,
+} from "wasm-ast-types";
+import { BuilderFileType } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+
+export const TYPE = "message-composer";
 
 export class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
   initContext(
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(
@@ -39,8 +41,8 @@ export class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
 
     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);
 
@@ -61,20 +63,27 @@ export class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
         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
-      }
+        body,
+      },
     ];
   }
 }

package/src/plugins/msg-builder.ts

@@ -16,7 +16,7 @@ export class MsgBuilderPlugin extends BuilderPluginBase<RenderOptions> {
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(

package/src/plugins/plugin-base.ts

@@ -1,15 +1,16 @@
-import { sync as mkdirp } from 'mkdirp';
-import { join } from 'path';
-import { writeFileSync } from 'fs';
-import { header } from '../utils/header';
+import { sync as mkdirp } from "mkdirp";
+import { join } from "path";
+import { writeFileSync } from "fs";
+import { header } from "../utils/header";
+import { ContractInfo, UtilMapping, IContext } from "wasm-ast-types";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
 import {
-  ContractInfo,
-  UtilMapping,
-  IContext
-} from 'wasm-ast-types';
-import generate from '@babel/generator';
-import * as t from '@babel/types';
-import { BuilderFile, BuilderFileType, TSBuilderOptions } from '../builder';
+  BuilderFile,
+  BuilderFileType,
+  TSBuilder,
+  TSBuilderOptions,
+} from "../builder";
 
 /**
  * IBuilderPlugin is a common plugin that render generated code.
@@ -20,6 +21,10 @@ export interface IBuilderPlugin {
    */
   utils: UtilMapping;
 
+  builder?: TSBuilder;
+
+  setBuilder(builder: TSBuilder);
+
   /**
    * render generated cdoe.
    * @param name the name of contract
@@ -30,19 +35,27 @@ export interface IBuilderPlugin {
   render(
     name: string,
     contractInfo: ContractInfo,
-    outPath: string,
+    outPath: string
   ): Promise<BuilderFile[]>;
 }
 
 /**
  * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
  */
-export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }> implements IBuilderPlugin {
+export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }>
+  implements IBuilderPlugin
+{
+  builder?: TSBuilder;
   option: TOpt;
   utils: UtilMapping;
 
-  constructor(opt: TOpt) {
+  constructor(opt: TOpt, builder?: TSBuilder) {
     this.option = opt;
+    this.builder = builder;
+  }
+
+  setBuilder(builder: TSBuilder) {
+    this.builder = builder;
   }
 
   async render(
@@ -65,7 +78,7 @@ export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }> impl
     }
 
     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;
 
@@ -78,7 +91,7 @@ export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }> impl
         pluginType: result.pluginType,
         contract: name,
         localname: result.localname,
-        filename
+        filename,
       };
     });
   }
@@ -88,10 +101,7 @@ export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }> impl
    * @param contract
    * @param options
    */
-  abstract initContext(
-    contract: ContractInfo,
-    options?: TOpt
-  ): IContext;
+  abstract initContext(contract: ContractInfo, options?: TOpt): IContext;
 
   /**
    * render generated code here.

package/src/plugins/provider-bundle.ts

@@ -0,0 +1,97 @@
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { ContractInfo, RenderContextBase, RenderContext } from "wasm-ast-types";
+import { BuilderFileType, TSBuilderOptions } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+import { GetLocalBaseNameByContractName } from "./provider";
+
+export class ContractsProviderBundlePlugin extends BuilderPluginBase<TSBuilderOptions> {
+  constructor(opt: TSBuilderOptions) {
+    super(opt);
+
+    this.utils = {
+      CosmWasmClient: "@cosmjs/cosmwasm-stargate",
+      SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
+      IQueryClientProvider: "__contractContextBase__",
+      ISigningClientProvider: "__contractContextBase__",
+      IMessageComposerProvider: "__contractContextBase__",
+    };
+  }
+
+  initContext(
+    contract: ContractInfo,
+    options?: TSBuilderOptions
+  ): RenderContextBase<TSBuilderOptions> {
+    return new RenderContext(contract, options, this.builder.builderContext);
+  }
+
+  async doRender(
+    name: string,
+    context: RenderContext
+  ): Promise<
+    {
+      type: BuilderFileType;
+      pluginType?: string;
+      localname: string;
+      body: any[];
+    }[]
+  > {
+    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,
+      },
+    ];
+  }
+}