wasm-ast-types 0.26.4 → 1.1.0

package/esm/context/context.js

@@ -0,0 +1,104 @@
+import { refLookup } from "../utils";
+import { convertUtilsToImportList, getImportStatements } from "./imports";
+import deepmerge from "deepmerge";
+import { basename, extname } from 'path';
+;
+export const defaultOptions = {
+    enabled: true,
+    types: {
+        enabled: true,
+        itemsUseTuples: false,
+        aliasExecuteMsg: false
+    },
+    client: {
+        enabled: true,
+        execExtendsQuery: true,
+        noImplicitOverride: false,
+    },
+    recoil: {
+        enabled: false
+    },
+    messageComposer: {
+        enabled: false
+    },
+    messageBuilder: {
+        enabled: false,
+    },
+    reactQuery: {
+        enabled: false,
+        optionalClient: false,
+        version: 'v4',
+        mutations: false,
+        camelize: true,
+        queryKeys: false
+    }
+};
+export const getDefinitionSchema = (schemas) => {
+    const aggregateSchema = {
+        definitions: {
+        //
+        }
+    };
+    schemas.forEach(schema => {
+        schema.definitions = schema.definitions || {};
+        aggregateSchema.definitions = {
+            ...aggregateSchema.definitions,
+            ...schema.definitions
+        };
+    });
+    return aggregateSchema;
+};
+export class BuilderContext {
+    providers = {};
+    addProviderInfo(contractName, type, classname, filename) {
+        if (!this.providers[contractName]) {
+            this.providers[contractName] = {};
+        }
+        this.providers[contractName][type] = {
+            classname,
+            filename,
+            basename: basename(filename, extname(filename))
+        };
+    }
+    getProviderInfos() {
+        return this.providers;
+    }
+}
+/**
+ * context object for generating code.
+ * only mergeDefaultOpt needs to implementing for combine options and default options.
+ * @param TOpt option type
+ */
+export class RenderContextBase {
+    builderContext;
+    contract;
+    utils = {};
+    schema;
+    options;
+    constructor(contract, options, builderContext) {
+        this.contract = contract;
+        this.schema = getDefinitionSchema(contract.schemas);
+        this.options = this.mergeDefaultOpt(options);
+        this.builderContext = builderContext;
+    }
+    refLookup($ref) {
+        return refLookup($ref, this.schema);
+    }
+    addUtil(util) {
+        this.utils[util] = true;
+    }
+    addProviderInfo(contractName, type, classname, filename) {
+        this.builderContext.addProviderInfo(contractName, type, classname, filename);
+    }
+    getProviderInfos() {
+        return this.builderContext.providers;
+    }
+    getImports(registeredUtils, filepath) {
+        return getImportStatements(convertUtilsToImportList(this, Object.keys(this.utils), registeredUtils), filepath);
+    }
+}
+export class RenderContext extends RenderContextBase {
+    mergeDefaultOpt(options) {
+        return deepmerge(defaultOptions, options ?? {});
+    }
+}

package/esm/context/imports.js

@@ -0,0 +1,136 @@
+import * as t from '@babel/types';
+import { importAs, importStmt } from "../utils";
+import { relative, dirname, extname } from 'path';
+const makeReactQuerySwitch = (varName) => {
+    return (context) => {
+        switch (context.options.reactQuery.version) {
+            case 'v4':
+                return {
+                    type: 'import',
+                    path: '@tanstack/react-query',
+                    name: varName
+                };
+            case 'v3':
+            default:
+                return {
+                    type: 'import',
+                    path: 'react-query',
+                    name: varName
+                };
+        }
+    };
+};
+export const UTILS = {
+    selectorFamily: 'recoil',
+    MsgExecuteContract: 'cosmjs-types/cosmwasm/wasm/v1/tx',
+    MsgExecuteContractEncodeObject: '@cosmjs/cosmwasm-stargate',
+    Coin: '@cosmjs/amino',
+    toUtf8: '@cosmjs/encoding',
+    StdFee: '@cosmjs/amino',
+    CosmWasmClient: '@cosmjs/cosmwasm-stargate',
+    ExecuteResult: '@cosmjs/cosmwasm-stargate',
+    SigningCosmWasmClient: '@cosmjs/cosmwasm-stargate',
+    // react-query
+    useQuery: makeReactQuerySwitch('useQuery'),
+    UseQueryOptions: makeReactQuerySwitch('UseQueryOptions'),
+    useMutation: makeReactQuerySwitch('useMutation'),
+    UseMutationOptions: makeReactQuerySwitch('UseMutationOptions')
+};
+export const UTIL_HELPERS = [
+    '__contractContextBase__',
+];
+export const convertUtilsToImportList = (context, utils, registeredUtils) => {
+    return utils.map((util) => {
+        let result = null;
+        if (registeredUtils) {
+            result = convertUtil(context, util, registeredUtils);
+            if (result) {
+                return result;
+            }
+        }
+        result = convertUtil(context, util, UTILS);
+        if (result) {
+            return result;
+        }
+        throw new Error(`missing Util! ::[${util}]`);
+    });
+};
+export const convertUtil = (context, util, registeredUtils) => {
+    if (!registeredUtils.hasOwnProperty(util))
+        return null;
+    if (typeof registeredUtils[util] === 'string') {
+        return {
+            type: 'import',
+            path: registeredUtils[util],
+            name: util
+        };
+    }
+    else if (typeof registeredUtils[util] === 'function') {
+        return registeredUtils[util](context);
+    }
+    else {
+        return registeredUtils[util];
+    }
+};
+// __helpers__
+export const getImportStatements = (list, filepath) => {
+    // swap helpers with helpers file...
+    const modifiedImports = list.map(imp => {
+        if (filepath && UTIL_HELPERS.includes(imp.path)) {
+            const name = imp.path.replace(/__/g, '');
+            return {
+                ...imp,
+                path: getRelativePath(filepath, `./${name}`)
+            };
+        }
+        return imp;
+    });
+    const imports = modifiedImports.reduce((m, obj) => {
+        m[obj.path] = m[obj.path] || [];
+        const exists = m[obj.path].find((el) => el.type === obj.type && el.path === obj.path && el.name === obj.name);
+        // MARKED AS NOT DRY [google.protobuf names]
+        // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+        if (/\./.test(obj.name)) {
+            obj.name = obj.name.split('.')[obj.name.split('.').length - 1];
+        }
+        if (!exists) {
+            m[obj.path].push(obj);
+        }
+        return m;
+    }, {});
+    return Object.entries(imports)
+        .reduce((m, [importPath, imports]) => {
+        const defaultImports = imports.filter(a => a.type === 'default');
+        if (defaultImports.length) {
+            if (defaultImports.length > 1)
+                throw new Error('more than one default name NOT allowed.');
+            m.push(t.importDeclaration([
+                t.importDefaultSpecifier(t.identifier(defaultImports[0].name))
+            ], t.stringLiteral(defaultImports[0].path)));
+        }
+        const namedImports = imports.filter(a => a.type === 'import' && (!a.importAs || (a.name === a.importAs)));
+        if (namedImports.length) {
+            m.push(importStmt(namedImports.map(i => i.name), namedImports[0].path));
+        }
+        const aliasNamedImports = imports.filter(a => a.type === 'import' && (a.importAs && (a.name !== a.importAs)));
+        aliasNamedImports.forEach(imp => {
+            m.push(importAs(imp.name, imp.importAs, imp.path));
+        });
+        const namespaced = imports.filter(a => a.type === 'namespace');
+        if (namespaced.length) {
+            if (namespaced.length > 1)
+                throw new Error('more than one namespaced name NOT allowed.');
+            m.push(t.importDeclaration([
+                t.importNamespaceSpecifier(t.identifier(namespaced[0].name))
+            ], t.stringLiteral(namespaced[0].path)));
+        }
+        return m;
+    }, []);
+};
+export const getRelativePath = (f1, f2) => {
+    const rel = relative(dirname(f1), f2);
+    let importPath = rel.replace(extname(rel), '');
+    if (!/^\./.test(importPath))
+        importPath = `./${importPath}`;
+    return importPath;
+};

package/{module → esm}/context/index.js

@@ -1,2 +1,2 @@
 export * from './context';
-export * from './imports';
+export * from './imports';

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

@@ -4,6 +4,5 @@ export * from './context';
 export * from './recoil';
 export * from './message-composer';
 export * from './react-query';
-export * from './types';
 export * from './message-builder';
 export * from './provider';

package/esm/message-builder/message-builder.js

@@ -0,0 +1,64 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { createTypedObjectParams } from '../utils/types';
+import { getWasmMethodArgs } from '../client/client';
+export const createMessageBuilderClass = (context, className, msg) => {
+    const staticMethods = getMessageProperties(msg).map((schema) => {
+        return createStaticExecMethodMessageBuilder(context, schema, msg.title);
+    });
+    // const blockStmt = bindings;
+    return t.exportNamedDeclaration(abstractClassDeclaration(className, staticMethods, [], null));
+};
+/**
+ * CamelCasedProperties<Extract<ExecuteMsg, { exec_on_module: unknown }>['exec_on_module']>
+ */
+function createExtractTypeAnnotation(underscoreName, msgTitle) {
+    return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CamelCasedProperties'), t.tsTypeParameterInstantiation([
+        t.tsIndexedAccessType(t.tsTypeReference(t.identifier('Extract'), t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier(msgTitle)),
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))
+            ])
+        ])), t.tsLiteralType(t.stringLiteral(underscoreName)))
+    ])));
+}
+const createStaticExecMethodMessageBuilder = (context, jsonschema, msgTitle) => {
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+    // what the underscore named property in the message is assigned to
+    let actionValue;
+    if (param?.type === 'Identifier') {
+        actionValue = t.identifier(param.name);
+    }
+    else {
+        actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
+    }
+    // TODO: this is a hack to get the type annotation to work
+    // all type annotations in the future should be the extracted and camelized type
+    if (param &&
+        param.typeAnnotation.type === 'TSTypeAnnotation' &&
+        param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
+        param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+    }
+    return t.classProperty(t.identifier(methodName), arrowFunctionExpression(
+    // params
+    param
+        ? [
+            // props
+            param
+        ]
+        : [], 
+    // body
+    t.blockStatement([
+        t.returnStatement(t.objectExpression([
+            t.objectProperty(t.identifier(underscoreName), actionValue)
+        ]))
+    ]), 
+    // return type
+    t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))), false), null, null, false, 
+    // static
+    true);
+};

package/esm/message-composer/message-composer.js

@@ -0,0 +1,105 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { arrowFunctionExpression, bindMethod, classDeclaration, classProperty, getMessageProperties, OPTIONAL_FUNDS_PARAM, typedIdentifier } from '../utils';
+import { createTypedObjectParams } from '../utils/types';
+import { getWasmMethodArgs } from '../client/client';
+const createWasmExecMethodMessageComposer = (context, jsonschema) => {
+    context.addUtil('Coin');
+    context.addUtil('MsgExecuteContractEncodeObject');
+    context.addUtil('MsgExecuteContract');
+    context.addUtil('toUtf8');
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+    // what the underscore named property in the message is assigned to
+    let actionValue;
+    if (param?.type === 'Identifier') {
+        actionValue = t.identifier(param.name);
+    }
+    else {
+        actionValue = t.objectExpression(args);
+    }
+    const constantParams = [OPTIONAL_FUNDS_PARAM];
+    return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param
+        ? [
+            // props
+            param,
+            ...constantParams
+        ]
+        : constantParams, t.blockStatement([
+        t.returnStatement(t.objectExpression([
+            t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')),
+            t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [
+                t.objectExpression([
+                    t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))),
+                    t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))),
+                    t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [
+                        t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [
+                            t.objectExpression([
+                                t.objectProperty(t.identifier(underscoreName), actionValue)
+                            ])
+                        ])
+                    ])),
+                    t.objectProperty(t.identifier('funds'), t.identifier('_funds'))
+                ])
+            ]))
+        ]))
+    ]), 
+    // return type
+    t.tsTypeAnnotation(t.tsTypeReference(t.identifier('MsgExecuteContractEncodeObject'))), false));
+};
+export const createMessageComposerClass = (context, className, implementsClassName, execMsg) => {
+    const propertyNames = getMessageProperties(execMsg)
+        .map((method) => Object.keys(method.properties)?.[0])
+        .filter(Boolean);
+    const bindings = propertyNames.map(camel).map(bindMethod);
+    const methods = getMessageProperties(execMsg).map((schema) => {
+        return createWasmExecMethodMessageComposer(context, schema);
+    });
+    const blockStmt = [];
+    blockStmt.push(...[
+        t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('sender')), t.identifier('sender'))),
+        t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))),
+        ...bindings
+    ]);
+    return t.exportNamedDeclaration(classDeclaration(className, [
+        // sender
+        classProperty('sender', t.tsTypeAnnotation(t.tsStringKeyword())),
+        // contractAddress
+        classProperty('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword())),
+        // constructor
+        t.classMethod('constructor', t.identifier('constructor'), [
+            typedIdentifier('sender', t.tsTypeAnnotation(t.tsStringKeyword())),
+            typedIdentifier('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()))
+        ], t.blockStatement(blockStmt)),
+        ...methods
+    ], [t.tSExpressionWithTypeArguments(t.identifier(implementsClassName))], null));
+};
+export const createMessageComposerInterface = (context, className, execMsg) => {
+    const methods = getMessageProperties(execMsg).map((jsonschema) => {
+        const underscoreName = Object.keys(jsonschema.properties)[0];
+        const methodName = camel(underscoreName);
+        return createPropertyFunctionWithObjectParamsForMessageComposer(context, methodName, 'MsgExecuteContractEncodeObject', jsonschema.properties[underscoreName]);
+    });
+    const extendsAst = [];
+    return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, extendsAst, t.tSInterfaceBody([
+        // contract address
+        t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())),
+        // contract address
+        t.tSPropertySignature(t.identifier('sender'), t.tsTypeAnnotation(t.tsStringKeyword())),
+        ...methods
+    ])));
+};
+const createPropertyFunctionWithObjectParamsForMessageComposer = (context, methodName, responseType, jsonschema) => {
+    const obj = createTypedObjectParams(context, jsonschema);
+    const fixedParams = [OPTIONAL_FUNDS_PARAM];
+    const func = {
+        type: 'TSFunctionType',
+        typeAnnotation: t.tsTypeAnnotation(t.tsTypeReference(t.identifier(responseType))),
+        parameters: obj ? [obj, ...fixedParams] : fixedParams
+    };
+    return t.tSPropertySignature(t.identifier(methodName), t.tsTypeAnnotation(
+    // @ts-ignore:next-line
+    func));
+};

package/esm/provider/provider.js

@@ -0,0 +1,97 @@
+import * as t from "@babel/types";
+import { camel, pascal } from "case";
+import { PROVIDER_TYPES } from "../utils/constants";
+import { identifier, tsObjectPattern } from "../utils";
+export const createProvider = (name, providerInfos) => {
+    const classDeclaration = t.classDeclaration(t.identifier(name), t.identifier("ContractBase"), t.classBody([
+        t.classMethod("constructor", t.identifier("constructor"), [
+            tsObjectPattern([
+                t.objectProperty(t.identifier("address"), t.identifier("address"), false, true),
+                t.objectProperty(t.identifier("cosmWasmClient"), t.identifier("cosmWasmClient"), false, true),
+                t.objectProperty(t.identifier("signingCosmWasmClient"), t.identifier("signingCosmWasmClient"), false, true),
+            ], t.tsTypeAnnotation(t.tsTypeReference(t.identifier("IContractConstructor")))),
+        ], t.blockStatement([
+            t.expressionStatement(t.callExpression(t.super(), [
+                t.identifier("address"),
+                t.identifier("cosmWasmClient"),
+                t.identifier("signingCosmWasmClient"),
+                t.identifier(providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE]
+                    ? providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE].classname
+                    : "undefined"),
+                t.identifier(providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE]
+                    ? providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE].classname
+                    : "undefined"),
+                t.identifier(providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+                    ? providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+                        .classname
+                    : "undefined"),
+            ])),
+        ])),
+    ]));
+    classDeclaration.superTypeParameters = t.tsTypeParameterInstantiation([
+        t.tsTypeReference(t.identifier(providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE]
+            ? providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE].classname
+            : "IEmptyClient")),
+        t.tsTypeReference(t.identifier(providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE]
+            ? providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE].classname
+            : "IEmptyClient")),
+        t.tsTypeReference(t.identifier(providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+            ? providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE].classname
+            : "IEmptyClient")),
+    ]);
+    return t.exportNamedDeclaration(classDeclaration);
+};
+export const createIContractsContext = (providerInfos) => {
+    const properties = [];
+    for (const key in providerInfos) {
+        if (Object.prototype.hasOwnProperty.call(providerInfos, key)) {
+            const contractProviderInfo = providerInfos[key];
+            properties.push(createProperty(key, contractProviderInfo));
+        }
+    }
+    return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier("IContractsContext"), null, null, t.tsInterfaceBody(properties)));
+};
+let PROVIDER_MAPPING = {};
+PROVIDER_MAPPING[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = "ISigningClientProvider";
+PROVIDER_MAPPING[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = "IQueryClientProvider";
+PROVIDER_MAPPING[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE] =
+    "IMessageComposerProvider";
+export const createProperty = (name, providerInfos) => {
+    let typeAnnotation = null;
+    const keys = Object.keys(providerInfos);
+    if (keys?.length == 1) {
+        const key = keys[0];
+        typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(PROVIDER_MAPPING[key]), t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier(providerInfos[key].classname)),
+        ])));
+    }
+    else {
+        const typeRefs = [];
+        for (const key of keys) {
+            typeRefs.push(t.tsTypeReference(t.identifier(PROVIDER_MAPPING[key]), t.tsTypeParameterInstantiation([
+                t.tsTypeReference(t.identifier(providerInfos[key].classname)),
+            ])));
+        }
+        typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType(typeRefs));
+    }
+    return t.tsPropertySignature(t.identifier(camel(name)), typeAnnotation);
+};
+export const createGettingProviders = (providerInfos) => {
+    const properties = [];
+    for (const key of Object.keys(providerInfos)) {
+        properties.push(t.objectProperty(t.identifier(camel(key)), t.newExpression(t.identifier(pascal(key)), [
+            t.objectExpression([
+                t.objectProperty(t.identifier("address"), t.identifier("address"), false, true),
+                t.objectProperty(t.identifier("cosmWasmClient"), t.identifier("cosmWasmClient"), false, true),
+                t.objectProperty(t.identifier("signingCosmWasmClient"), t.identifier("signingCosmWasmClient"), false, true),
+            ]),
+        ])));
+    }
+    return t.exportNamedDeclaration(t.variableDeclaration("const", [
+        t.variableDeclarator(t.identifier("getProviders"), t.arrowFunctionExpression([
+            identifier("address?", t.tsTypeAnnotation(t.tsTypeReference(t.identifier("string")))),
+            identifier("cosmWasmClient?", t.tsTypeAnnotation(t.tsTypeReference(t.identifier("CosmWasmClient")))),
+            identifier("signingCosmWasmClient?", t.tsTypeAnnotation(t.tsTypeReference(t.identifier("SigningCosmWasmClient")))),
+        ], t.objectExpression(properties))),
+    ]));
+};