@cosmwasm/ts-codegen 1.12.1 → 1.13.1

package/esm/commands/generate.js

@@ -7,38 +7,33 @@ export default async (argv) => {
             type: 'path',
             name: 'schema',
             message: 'which directory contains the the Rust contracts?',
-            default: './schema'
+            default: './schema',
         },
         {
             _: true,
             type: 'path',
             name: 'out',
             message: 'where is the output directory?',
-            default: './ts'
+            default: './ts',
         },
         {
             _: true,
             type: 'string',
             name: 'name',
-            message: 'contract name?'
+            message: 'contract name?',
         },
         {
             type: 'checkbox',
             name: 'plugin',
             message: 'which plugins?',
-            choices: [
-                'client',
-                'recoil',
-                'react-query',
-                'message-composer'
-            ]
+            choices: ['client', 'recoil', 'react-query', 'message-composer'],
         },
         {
             type: 'confirm',
             name: 'bundle',
             message: 'enable bundle?',
-            default: true
-        }
+            default: true,
+        },
     ];
     if (argv.typesOnly) {
         argv.plugin = 'types';
@@ -55,24 +50,23 @@ export default async (argv) => {
                 type: 'confirm',
                 name: 'optionalClient',
                 message: 'optionalClient?',
-                default: false
+                default: false,
             },
             {
                 type: 'list',
                 name: 'version',
                 message: 'which react-query version?',
                 default: 'v4',
-                choices: ['v3', 'v4']
+                choices: ['v3', 'v4'],
             },
             {
                 type: 'confirm',
                 name: 'queryKeys',
                 message: 'queryKeys?',
-                default: false
+                default: false,
             },
         ]);
     }
-    ;
     const { optionalClient, version, queryKeys } = await prompt(questions2, argv);
     const questions3 = [];
     if (version === 'v4') {
@@ -82,11 +76,10 @@ export default async (argv) => {
                 type: 'confirm',
                 name: 'mutations',
                 message: 'Generate useMutation hooks?',
-                default: false
-            }
+                default: false,
+            },
         ]);
     }
-    ;
     const { mutations } = await prompt(questions3, argv);
     const queryFactoryQuestions = [];
     if (queryKeys) {
@@ -96,11 +89,10 @@ export default async (argv) => {
                 type: 'confirm',
                 name: 'queryFactory',
                 message: 'queryFactory? ',
-                default: false
-            }
+                default: false,
+            },
         ]);
     }
-    ;
     const { queryFactory } = await prompt(queryFactoryQuestions, argv);
     ///////// END REACT QUERY
     ///////// BUNDLE
@@ -111,27 +103,26 @@ export default async (argv) => {
                 type: 'string',
                 name: 'bundleFile',
                 message: 'bundleFile?',
-                default: 'index.ts'
+                default: 'index.ts',
             },
             {
                 type: 'string',
                 name: 'bundleScope',
                 message: 'bundleScope?',
-                default: 'contracts'
-            }
+                default: 'contracts',
+            },
         ]);
     }
-    ;
     const { bundleFile, bundleScope } = await prompt(questions4, argv);
     ///////// END BUNDLE
     const options = {
         types: {
-            enabled: true
+            enabled: true,
         },
         client: {
             enabled: plugin.includes('client') ||
                 plugin.includes('recoil') ||
-                plugin.includes('react-query')
+                plugin.includes('react-query'),
         },
         reactQuery: {
             enabled: plugin.includes('react-query'),
@@ -139,31 +130,31 @@ export default async (argv) => {
             queryKeys,
             version,
             mutations,
-            queryFactory
+            queryFactory,
         },
         recoil: {
             enabled: plugin.includes('recoil'),
         },
         messageComposer: {
-            enabled: plugin.includes('message-composer')
+            enabled: plugin.includes('message-composer'),
         },
         messageBuilder: {
-            enabled: plugin.includes('message-builder')
+            enabled: plugin.includes('message-builder'),
         },
         bundle: {
             enabled: bundle,
             scope: bundleScope,
-            bundleFile
-        }
+            bundleFile,
+        },
     };
     await codegen({
         contracts: [
             {
                 name,
-                dir: schema
-            }
+                dir: schema,
+            },
         ],
         outPath: out,
-        options
+        options,
     });
 };

package/esm/commands/install.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from 'fs';
-import { sync as glob } from 'glob';
+import { globSync as glob } from 'glob';
 import { sync as mkdirp } from 'mkdirp';
 import { tmpdir } from 'os';
 import { parse } from 'parse-package-name';
@@ -11,10 +11,12 @@ const TMPDIR = tmpdir();
 const rnd = () => Math.random().toString(36).substring(2, 15) +
     Math.random().toString(36).substring(2, 15);
 const getPackages = (names) => {
-    return names.map(pkg => {
+    return names
+        .map((pkg) => {
         const { name, version } = parse(pkg);
         return `${name}@${version}`;
-    }).join(' ');
+    })
+        .join(' ');
 };
 export default async (argv) => {
     // don't prompt if we got this...
@@ -27,7 +29,7 @@ export default async (argv) => {
     try {
         thisPackage = JSON.parse(readFileSync(join(cur, 'package.json'), 'utf-8'));
     }
-    catch (e) {
+    catch {
         throw new Error('make sure you are inside of a telescope package!');
     }
     // what are we installing?
@@ -46,14 +48,14 @@ export default async (argv) => {
                 'stargaze-vending-factory',
                 'stargaze-vending-minter',
                 'stargaze-whitelist',
-                'wasmswap'
-            ].map(name => {
+                'wasmswap',
+            ].map((name) => {
                 return {
                     name,
-                    value: `@cosmjson/${name}`
+                    value: `@cosmjson/${name}`,
                 };
-            })
-        }
+            }),
+        },
     ], argv);
     // install
     if (!Array.isArray(pkg))
@@ -63,26 +65,28 @@ export default async (argv) => {
     process.chdir(tmp);
     exec(`npm install ${getPackages(pkg)} --production --prefix ./smart-contracts`);
     // protos
-    const pkgs = glob('./smart-contracts/**/package.json');
+    const pkgs = glob('./smart-contracts/**/package.json').sort();
     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))
+        const files = glob(`${extDir}/**/*`, { nodir: true }).sort();
+        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 
+    // move protos
     for (const [src, dst, pkg] of cmds) {
         rimraf(dst);
         console.log(`installing ${pkg}...`);
@@ -95,7 +99,7 @@ export default async (argv) => {
     thisPackage.devDependencies = thisPackage.devDependencies ?? {};
     thisPackage.devDependencies = {
         ...thisPackage.devDependencies,
-        ...deps
+        ...deps,
     };
     thisPackage.devDependencies = Object.fromEntries(Object.entries(thisPackage.devDependencies).sort());
     writeFileSync(join(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));

package/esm/file.js

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

package/esm/helpers/baseClient.js

@@ -0,0 +1,184 @@
+export const baseClient = `
+import { StdFee, Coin } from '@interchainjs/types';
+import { DirectSigner } from '@interchainjs/cosmos';
+import { getSmartContractState } from 'interchainjs/cosmwasm/wasm/v1/query.rpc.func';
+import { executeContract } from 'interchainjs/cosmwasm/wasm/v1/tx.rpc.func';
+import { QuerySmartContractStateRequest, QuerySmartContractStateResponse } from 'interchainjs/cosmwasm/wasm/v1/query';
+import { MsgExecuteContract } from 'interchainjs/cosmwasm/wasm/v1/tx';
+import { Chain } from '@chain-registry/v2-types';
+
+// Encoding utility functions
+const fromUint8Array = <T>(uint8Array: Uint8Array): T => {
+  const text = new TextDecoder().decode(uint8Array);
+  return JSON.parse(text);
+};
+
+const toUint8Array = (obj: any): Uint8Array => {
+  const text = JSON.stringify(obj);
+  return new TextEncoder().encode(text);
+};
+
+// Chain registry configuration
+// The amount under gasPrice represents gas price per unit
+export interface ChainConfig {
+  chain?: Chain;
+  gasPrice?: {
+    denom: string;
+    amount: string;
+  };
+}
+
+// Gas fee calculation utilities
+export const calculateGasFromChain = (chain: Chain, gasAmount: string): StdFee => {
+  try {
+    const feeTokens = chain.fees?.feeTokens;
+    
+    if (feeTokens && feeTokens.length > 0) {
+      const primaryToken = feeTokens[0];
+      // v2 chain-registry uses camelCase: averageGasPrice, lowGasPrice, fixedMinGasPrice
+      const gasPrice = primaryToken.averageGasPrice || primaryToken.lowGasPrice || primaryToken.fixedMinGasPrice || 0.025;
+      const gasAmountNum = parseInt(gasAmount);
+      const feeAmount = Math.ceil(gasAmountNum * gasPrice).toString();
+      
+      return {
+        amount: [{
+          denom: primaryToken.denom,
+          amount: feeAmount
+        }],
+        gas: gasAmount
+      };
+    }
+  } catch (error) {
+    console.warn('Failed to calculate gas from chain registry:', error);
+  }
+  
+  // Fallback to default
+  return { amount: [], gas: gasAmount };
+};
+
+// Default gas amount - users can easily change this
+export let DEFAULT_GAS_AMOUNT = '200000';
+
+// Allow users to set their preferred default gas amount
+export const setDefaultGasAmount = (gasAmount: string): void => {
+  DEFAULT_GAS_AMOUNT = gasAmount;
+};
+
+// Get current default gas amount
+export const getDefaultGasAmount = (): string => DEFAULT_GAS_AMOUNT;
+
+export const getAutoGasFee = (chainConfig?: ChainConfig): StdFee => {
+  const gasAmount = DEFAULT_GAS_AMOUNT;
+  
+  if (chainConfig?.chain) {
+    return calculateGasFromChain(chainConfig.chain, gasAmount);
+  }
+  
+  if (chainConfig?.gasPrice) {
+    const gasAmountNum = parseInt(gasAmount);
+    const gasPriceNum = parseFloat(chainConfig.gasPrice.amount);
+    const feeAmount = Math.ceil(gasAmountNum * gasPriceNum).toString();
+    
+    return {
+      amount: [{
+        denom: chainConfig.gasPrice.denom,
+        amount: feeAmount
+      }],
+      gas: gasAmount
+    };
+  }
+  
+  // Fallback: no fee tokens, just gas amount
+  return { amount: [], gas: gasAmount };
+};
+
+// InterchainJS interfaces for CosmWasm clients
+export interface ICosmWasmClient {
+  queryContractSmart(contractAddr: string, query: any): Promise<any>;
+}
+
+export interface ISigningCosmWasmClient {
+  execute(
+    sender: string, 
+    contractAddress: string, 
+    msg: any, 
+    fee?: number | StdFee | "auto", 
+    memo?: string, 
+    funds?: Coin[], 
+    chainConfig?: ChainConfig
+  ): Promise<any>;
+}
+
+export interface ISigningClient {
+  signAndBroadcast(
+    signerAddress: string,
+    messages: any[],
+    fee: number | StdFee | "auto",
+    memo?: string
+  ): Promise<any>;
+}
+
+// Helper functions to create InterchainJS clients
+export function getCosmWasmClient(rpcEndpoint: string): ICosmWasmClient {
+  return {
+    queryContractSmart: async (contractAddr: string, query: any) => {
+      // Create the request object
+      const request: QuerySmartContractStateRequest = {
+        address: contractAddr,
+        queryData: toUint8Array(query)
+      };
+      
+      // Execute the query using InterchainJS
+      const response: QuerySmartContractStateResponse = await getSmartContractState(rpcEndpoint, request);
+      
+      // Parse and return the result
+      return fromUint8Array(response.data);
+    },
+  };
+}
+
+export function getSigningCosmWasmClient(signingClient: DirectSigner): ISigningCosmWasmClient {
+  return {
+    execute: async (
+      sender: string, 
+      contractAddress: string, 
+      msg: any, 
+      fee?: number | StdFee | "auto", 
+      memo?: string, 
+      funds?: Coin[], 
+      chainConfig?: ChainConfig
+    ) => {
+      // Handle fee conversion
+      let finalFee: StdFee;
+      if (typeof fee === 'number') {
+        finalFee = { amount: [], gas: fee.toString() };
+      } else if (fee === 'auto') {
+        finalFee = getAutoGasFee(chainConfig);
+      } else if (fee) {
+        finalFee = fee;
+      } else {
+        finalFee = getAutoGasFee(chainConfig);
+      }
+
+      // Create the message object
+      const message: MsgExecuteContract = {
+        sender,
+        contract: contractAddress,
+        msg: toUint8Array(msg),
+        funds: funds || []
+      };
+      
+      // Execute the transaction using InterchainJS
+      const result = await executeContract(
+        signingClient as any,
+        sender,
+        message,
+        finalFee,
+        memo || ''
+      );
+      
+      return result;
+    },
+  };
+}
+`;

package/esm/helpers/contractContextBase.js

@@ -1,13 +1,15 @@
 export const contractContextBase = `
 import {
-  CosmWasmClient,
-  SigningCosmWasmClient,
-} from '@cosmjs/cosmwasm-stargate';
+  ICosmWasmClient,
+  ISigningCosmWasmClient,
+  getCosmWasmClient,
+  getSigningCosmWasmClient,
+} from './baseClient';
 
 export interface IContractConstructor {
   address: string | undefined;
-  cosmWasmClient: CosmWasmClient | undefined;
-  signingCosmWasmClient: SigningCosmWasmClient | undefined;
+  cosmWasmClient: ICosmWasmClient | undefined;
+  signingCosmWasmClient: ISigningCosmWasmClient | undefined;
 }
 
 export const NO_SINGING_ERROR_MESSAGE = 'signingCosmWasmClient not connected';
@@ -49,15 +51,15 @@ export class ContractBase<
 > {
 
   address: string | undefined;
-  cosmWasmClient: CosmWasmClient | undefined;
-  signingCosmWasmClient: SigningCosmWasmClient | undefined;
+  cosmWasmClient: ICosmWasmClient | undefined;
+  signingCosmWasmClient: ISigningCosmWasmClient | undefined;
   TSign?: new (
-    client: SigningCosmWasmClient,
+    client: ISigningCosmWasmClient,
     sender: string,
     contractAddress: string
   ) => TSign;
   TQuery?: new (
-    client: CosmWasmClient,
+    client: ICosmWasmClient,
     contractAddress: string
   ) => TQuery;
   TMsgComposer?: new (
@@ -67,15 +69,15 @@ export class ContractBase<
 
   constructor(
     address: string | undefined,
-    cosmWasmClient: CosmWasmClient | undefined,
-    signingCosmWasmClient: SigningCosmWasmClient | undefined,
+    cosmWasmClient: ICosmWasmClient | undefined,
+    signingCosmWasmClient: ISigningCosmWasmClient | undefined,
     TSign?: new (
-      client: SigningCosmWasmClient,
+      client: ISigningCosmWasmClient,
       sender: string,
       contractAddress: string
     ) => TSign,
     TQuery?: new (
-      client: CosmWasmClient,
+      client: ICosmWasmClient,
       contractAddress: string
     ) => TQuery,
     TMsgComposer?: new (

package/esm/helpers/contractContextBaseShortHandCtor.js

@@ -1,13 +1,15 @@
 export const contractContextBaseShortHandCtor = `
 import {
-  CosmWasmClient,
-  SigningCosmWasmClient,
-} from '@cosmjs/cosmwasm-stargate';
+  ICosmWasmClient,
+  ISigningCosmWasmClient,
+  getCosmWasmClient,
+  getSigningCosmWasmClient,
+} from './baseClient';
 
 export interface IContractConstructor {
   address: string | undefined;
-  cosmWasmClient: CosmWasmClient | undefined;
-  signingCosmWasmClient: SigningCosmWasmClient | undefined;
+  cosmWasmClient: ICosmWasmClient | undefined;
+  signingCosmWasmClient: ISigningCosmWasmClient | undefined;
 }
 
 export const NO_SINGING_ERROR_MESSAGE = 'signingCosmWasmClient not connected';
@@ -49,15 +51,15 @@ export class ContractBase<
 > {
   constructor(
     protected address: string | undefined,
-    protected cosmWasmClient: CosmWasmClient | undefined,
-    protected signingCosmWasmClient: SigningCosmWasmClient | undefined,
+    protected cosmWasmClient: ICosmWasmClient | undefined,
+    protected signingCosmWasmClient: ISigningCosmWasmClient | undefined,
     private TSign?: new (
-      client: SigningCosmWasmClient,
+      client: ISigningCosmWasmClient,
       sender: string,
       contractAddress: string
     ) => TSign,
     private TQuery?: new (
-      client: CosmWasmClient,
+      client: ICosmWasmClient,
       contractAddress: string
     ) => TQuery,
     private TMsgComposer?: new (

package/esm/helpers/contractsContextTSX.js

@@ -1,16 +1,16 @@
 export const contractsContextTSX = `
 import React, { useEffect, useMemo, useRef, useState, useContext } from 'react';
 import {
-  CosmWasmClient,
-  SigningCosmWasmClient,
-} from '@cosmjs/cosmwasm-stargate';
+  ICosmWasmClient,
+  ISigningCosmWasmClient,
+} from './baseClient';
 
 import { IContractsContext, getProviders } from './contractContextProviders';
 
 export interface ContractsConfig {
   address: string | undefined;
-  getCosmWasmClient: () => Promise<CosmWasmClient>;
-  getSigningCosmWasmClient: () => Promise<SigningCosmWasmClient>;
+  getCosmWasmClient: () => Promise<ICosmWasmClient>;
+  getSigningCosmWasmClient: () => Promise<ISigningCosmWasmClient>;
 }
 
 const ContractsContext = React.createContext<IContractsContext | null>(null);
@@ -22,9 +22,9 @@ export const ContractsProvider = ({
   children: React.ReactNode;
   contractsConfig: ContractsConfig;
 }) => {
-  const [cosmWasmClient, setCosmWasmClient] = useState<CosmWasmClient>();
+  const [cosmWasmClient, setCosmWasmClient] = useState<ICosmWasmClient>();
   const [signingCosmWasmClient, setSigningCosmWasmClient] =
-    useState<SigningCosmWasmClient>();
+    useState<ISigningCosmWasmClient>();
 
   const { address, getCosmWasmClient, getSigningCosmWasmClient } =
     contractsConfig;

package/esm/helpers/create-helpers.js

@@ -1,6 +1,6 @@
 import { sync as mkdirp } from 'mkdirp';
 import { basename, dirname, extname, join } from 'path';
-import { contractContextBase, contractContextBaseShortHandCtor, contractsContextTSX, } from '../helpers';
+import { contractContextBase, contractContextBaseShortHandCtor, contractsContextTSX, baseClient, } from '../helpers';
 import { writeContentToFile } from '../utils/files';
 import { header } from '../utils/header';
 const write = (outPath, file, content, varname) => {
@@ -17,6 +17,8 @@ const write = (outPath, file, content, varname) => {
 };
 export const createHelpers = (input, builderContext) => {
     const files = [];
+    // Always generate baseClient.ts since InterchainJS interfaces are needed by all clients
+    files.push(write(input.outPath, 'baseClient.ts', baseClient));
     if (input.options?.useContractsHook?.enabled &&
         Object.keys(builderContext.providers)?.length) {
         const useShorthandCtor = input.options?.useShorthandCtor;

package/esm/helpers/index.js

@@ -1,3 +1,4 @@
 export * from './contractContextBase';
 export * from './contractContextBaseShortHandCtor';
+export * from './baseClient';
 export * from './contractsContextTSX';

package/esm/plugins/client.js

@@ -43,7 +43,7 @@ export class ClientPlugin extends BuilderPluginBase {
                 context.addProviderInfo(name, w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE, Client, localname);
             }
         }
-        if (typeHash.hasOwnProperty('Coin')) {
+        if (Object.prototype.hasOwnProperty.call(typeHash, 'Coin')) {
             // @ts-ignore
             delete context.utils.Coin;
         }

package/esm/plugins/message-builder.js

@@ -1,5 +1,5 @@
 import * as w from '@cosmwasm/ts-codegen-ast';
-import { getMessageProperties, RenderContext } from '@cosmwasm/ts-codegen-ast';
+import { getMessageProperties, RenderContext, } from '@cosmwasm/ts-codegen-ast';
 import { pascal } from 'case';
 import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
 import { BuilderPluginBase } from './plugin-base';
@@ -37,7 +37,7 @@ export class MessageBuilderPlugin extends BuilderPluginBase {
                 body.push(w.createMessageBuilderClass(context, className, QueryMsg));
             }
         }
-        if (typeHash.hasOwnProperty('Coin')) {
+        if (Object.prototype.hasOwnProperty.call(typeHash, 'Coin')) {
             // @ts-ignore
             delete context.utils.Coin;
         }
@@ -45,8 +45,8 @@ export class MessageBuilderPlugin extends BuilderPluginBase {
             {
                 type: 'message-builder',
                 localname,
-                body
-            }
+                body,
+            },
         ];
     }
 }

package/esm/plugins/message-composer.js

@@ -30,7 +30,7 @@ export class MessageComposerPlugin extends BuilderPluginBase {
                 context.addProviderInfo(name, w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE, TheClass, localname);
             }
         }
-        if (typeHash.hasOwnProperty('Coin')) {
+        if (Object.prototype.hasOwnProperty.call(typeHash, 'Coin')) {
             // @ts-ignore
             delete context.utils.Coin;
         }