@hyperweb/telescope 1.15.0

package/module/commands/transpile.js

@@ -0,0 +1,169 @@
+import { prompt } from '../prompt';
+import telescope from '../index';
+import { writeFileSync, readFileSync } from 'fs';
+import { defaultTelescopeOptions } from '@cosmology/types';
+import * as path from 'path';
+import * as dotty from 'dotty';
+import deepmerge from 'deepmerge';
+export default async (argv) => {
+    let options = {};
+    let protoDirs;
+    let outPath;
+    let data;
+    let overrideConfig = true;
+    if (argv.useDefaults) {
+        const defaultOptions = { ...defaultTelescopeOptions };
+        dotty.remove(defaultOptions, "aminoEncoding");
+        dotty.remove(defaultOptions, "packages");
+        options = defaultOptions;
+    }
+    else {
+        options = {
+            // global options (can be overridden through plugins)
+            interfaces: {
+                enabled: false,
+                useByDefault: false,
+                useUnionTypes: false,
+            },
+            prototypes: {
+                enabled: true,
+                parser: {
+                    keepCase: false
+                },
+                methods: {
+                    fromJSON: false,
+                    toJSON: false,
+                    encode: true,
+                    decode: true,
+                    fromPartial: true,
+                    toAmino: true,
+                    fromAmino: true,
+                    fromProto: true,
+                    toProto: true
+                },
+                addTypeUrlToObjects: true,
+                addTypeUrlToDecoders: true,
+                typingsFormat: {
+                    duration: 'duration',
+                    timestamp: 'date',
+                    useExact: false,
+                    useDeepPartial: false,
+                    num64: 'bigint',
+                    customTypes: {
+                        useCosmosSDKDec: true
+                    }
+                },
+            },
+            bundle: {
+                enabled: true
+            },
+            stargateClients: {
+                enabled: true,
+                includeCosmosDefaultTypes: true
+            },
+            aminoEncoding: {
+                enabled: true,
+            },
+            lcdClients: {
+                enabled: true
+            },
+            rpcClients: {
+                enabled: true,
+                camelCase: true
+            }
+        };
+    }
+    const questions = [
+        {
+            _: true,
+            type: 'path',
+            name: 'protoDirs',
+            message: 'where is the proto directory?',
+            default: './proto'
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'outPath',
+            message: 'where is the output directory?',
+            default: './src/codegen'
+        }
+    ];
+    if (argv.config) {
+        overrideConfig = false;
+        const { config } = argv;
+        const configs = Array.isArray(config) ? config : [config];
+        const inputConfigFullPaths = configs.map(c => path.resolve(c));
+        let configJson;
+        for (const inputConfigPath of inputConfigFullPaths) {
+            try {
+                const configText = readFileSync(inputConfigPath, {
+                    encoding: 'utf8'
+                });
+                if (configJson) {
+                    configJson = deepmerge(configJson, JSON.parse(configText));
+                }
+                else {
+                    configJson = JSON.parse(configText);
+                }
+            }
+            catch (ex) {
+                console.log(ex);
+                throw new Error("Must provide a .json file for --config.");
+            }
+        }
+        // append protoDirs in config to argv.protoDirs
+        argv.protoDirs = [
+            ...(argv.protoDirs
+                ? Array.isArray(argv.protoDirs)
+                    ? argv.protoDirs
+                    : [argv.protoDirs]
+                : []),
+            ...(configJson.protoDirs ?? []),
+        ];
+        if (configJson.outPath) {
+            argv.outPath = configJson.outPath;
+        }
+        // For now, useDefaults will be override by --config
+        if (configJson.options) {
+            options = configJson.options;
+        }
+    }
+    if (!argv.config && !argv.useDefaults) {
+        try {
+            //check if there's valid .telescope.json file to use
+            data = JSON.parse(readFileSync('./.telescope.json', {
+                encoding: 'utf8'
+            }));
+        }
+        catch (e) { }
+        //if there's existing valid .telescope.json, use and keep the file
+        if (data?.protoDirs && data?.outPath && data?.options) {
+            overrideConfig = false;
+            protoDirs = data.protoDirs;
+            outPath = data.outPath;
+            options = data.options;
+        }
+    }
+    if (!protoDirs || !outPath) {
+        ({ protoDirs, outPath } = await prompt(questions, argv));
+    }
+    if (!Array.isArray(protoDirs)) {
+        protoDirs = [protoDirs];
+    }
+    // remove any duplicate protodirs
+    protoDirs = [...new Set(protoDirs)];
+    if (overrideConfig) {
+        writeFileSync(process.cwd() + '/.telescope.json', JSON.stringify({
+            protoDirs,
+            outPath,
+            options
+        }, null, 2));
+    }
+    await telescope({
+        protoDirs,
+        outPath,
+        options
+    });
+    console.log(`✨ transpilation successful!`);
+};

package/module/contracts/generate.js

@@ -0,0 +1,29 @@
+import { prompt } from '../prompt';
+import { generateClient } from '@cosmwasm/ts-codegen';
+import { getContracts, getContractSchemata } from '../utils/contracts';
+export default async (argv) => {
+    const contracts = getContracts();
+    const questions = [
+        {
+            _: true,
+            type: 'checkbox',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            choices: contracts
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './src/contracts'
+        }
+    ];
+    let { schema, out } = await prompt(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await getContractSchemata(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await generateClient(contractName, schemas, outPath);
+    });
+};

package/module/contracts/install.js

@@ -0,0 +1,105 @@
+import { resolve, join, dirname, basename, extname } from 'path';
+import { crossGlob as glob } from '@cosmology/utils';
+import { mkdirp } from 'mkdirp';
+import { rimrafSync as rimraf } from 'rimraf';
+import { exec } from 'shelljs';
+import { prompt } from '../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) +
+    Math.random().toString(36).substring(2, 15);
+const getPackages = (names) => {
+    return names.map(pkg => {
+        const { name, version } = parse(pkg);
+        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) {
+        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?',
+            choices: [
+                'stargaze-base-factory',
+                'stargaze-base-minter',
+                'stargaze-sg721-base',
+                'stargaze-sg721-metdata-onchain',
+                'stargaze-sg721-nt',
+                'stargaze-splits',
+                'stargaze-vending-factory',
+                'stargaze-vending-minter',
+                'stargaze-whitelist',
+                'wasmswap',
+            ].map(name => {
+                return {
+                    name,
+                    value: `@cosmjson/${name}`
+                };
+            })
+        }
+    ], argv);
+    // install
+    if (!Array.isArray(pkg))
+        pkg = [pkg];
+    const tmp = join(TMPDIR, rnd());
+    mkdirp.sync(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'; })
+        .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];
+    });
+    // move protos
+    for (const [src, dst, pkg] of cmds) {
+        rimraf(dst);
+        console.log(`installing ${pkg}...`);
+        mkdirp.sync(dirname(dst));
+        exec(`mv ${src} ${dst}`);
+    }
+    // package
+    const packageInfo = JSON.parse(readFileSync('./smart-contracts/package.json', 'utf-8'));
+    const deps = packageInfo.dependencies ?? {};
+    thisPackage.devDependencies = thisPackage.devDependencies ?? {};
+    thisPackage.devDependencies = {
+        ...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/module/contracts/message-composer.js

@@ -0,0 +1,29 @@
+import { prompt } from '../prompt';
+import { generateMessageComposer } from '@cosmwasm/ts-codegen';
+import { getContracts, getContractSchemata } from '../utils/contracts';
+export default async (argv) => {
+    const contracts = getContracts();
+    const questions = [
+        {
+            _: true,
+            type: 'checkbox',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            choices: contracts
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './src/contracts'
+        }
+    ];
+    let { schema, out } = await prompt(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await getContractSchemata(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await generateMessageComposer(contractName, schemas, outPath);
+    });
+};

package/module/contracts/react-query.js

@@ -0,0 +1,29 @@
+import { prompt } from '../prompt';
+import { generateReactQuery } from '@cosmwasm/ts-codegen';
+import { getContracts, getContractSchemata } from '../utils/contracts';
+export default async (argv) => {
+    const contracts = getContracts();
+    const questions = [
+        {
+            _: true,
+            type: 'checkbox',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            choices: contracts
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './src/contracts'
+        }
+    ];
+    let { schema, out } = await prompt(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await getContractSchemata(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await generateReactQuery(contractName, schemas, outPath);
+    });
+};

package/module/contracts/recoil.js

@@ -0,0 +1,29 @@
+import { prompt } from '../prompt';
+import { generateRecoil } from '@cosmwasm/ts-codegen';
+import { getContracts, getContractSchemata } from '../utils/contracts';
+export default async (argv) => {
+    const contracts = getContracts();
+    const questions = [
+        {
+            _: true,
+            type: 'checkbox',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            choices: contracts
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './src/contracts'
+        }
+    ];
+    let { schema, out } = await prompt(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await getContractSchemata(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await generateRecoil(contractName, schemas, outPath);
+    });
+};

package/module/file.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { prompt } from './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/module/generators/create-aggregated-lcd-client.js

@@ -0,0 +1,83 @@
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+import { getNestedProto, isRefIncluded, isRefExcluded } from '@cosmology/proto-parser';
+import { parse } from '../parse';
+import { join } from 'path';
+import { createAggregatedLCDClient } from '@cosmology/ast';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { fixlocalpaths } from '../utils';
+export const plugin = (builder) => {
+    if (!builder.options.aggregatedLCD) {
+        return;
+    }
+    const opts = builder.options.aggregatedLCD;
+    const { dir, filename: fname, packages, protos } = opts;
+    const localname = join(dir, fname);
+    const refs = builder.store.filterProtoWhere((ref) => {
+        return isRefIncluded(ref, {
+            packages,
+            protos
+        }) && !isRefExcluded(ref, builder.options.prototypes?.excluded);
+    });
+    const services = refs.map(ref => {
+        const proto = getNestedProto(ref.traversed);
+        if (!proto?.Query || proto.Query?.type !== 'Service') {
+            return;
+        }
+        return proto.Query;
+    }).filter(Boolean);
+    const tc = new TelescopeParseContext(refs[0], builder.store, builder.options);
+    const context = tc.proto;
+    const lcdast = createAggregatedLCDClient(context, services, 'QueryClient');
+    const importsForAggregator = aggregateImports(tc, {}, localname);
+    /////////
+    /////////
+    /////////
+    /////////
+    const queryContexts = builder
+        .contexts
+        .filter(context => context.queries.length > 0 ||
+        context.services.length > 0);
+    const progImports = queryContexts.reduce((m, c) => {
+        if (!isRefIncluded(c.ref, {
+            packages,
+            protos
+        })) {
+            return m;
+        }
+        const ctx = new TelescopeParseContext(c.ref, c.store, builder.options);
+        // get mutations, services
+        parse(ctx);
+        const proto = getNestedProto(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        ///
+        let getImportsFrom;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+            }
+        });
+        const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+        const imports = aggregateImports(ctx, serviceImports, localname);
+        return [...m, ...fixlocalpaths(imports)];
+    }, []);
+    const importStmts = getImportStatements(localname, [...importsForAggregator, ...progImports], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const filename = join(builder.outPath, localname);
+    writeAstToFile(builder.outPath, builder.options, prog, filename);
+};

package/module/generators/create-all-stargate-clients.js

@@ -0,0 +1,92 @@
+import { join, dirname, relative } from 'path';
+import { importNamespace, GenericParseContext, createStargateClient, createStargateClientOptions, createStargateClientProtoRegistry, createStargateClientAminoRegistry, createGetTxRpc } from '@cosmology/ast';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+import { writeAstToFile } from '../utils/files';
+export const plugin = (builder, allRegistries, allConverters) => {
+    if (!allRegistries || !allRegistries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = 'all-module-client.ts';
+    builder.files.push(clientFile);
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: null,
+            root: {},
+        }
+    };
+    const ctx = new GenericParseContext(ctxRef, null, builder.options);
+    const registryVariables = [];
+    const converterVariables = [];
+    allRegistries.forEach(registry => {
+        let rel = relative(dirname(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push(importNamespace(variable, rel));
+    });
+    allConverters.forEach(converter => {
+        let rel = relative(dirname(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push(importNamespace(variable, rel));
+    });
+    const name = 'get' + pascal('AllSigningClient');
+    const txRpcName = 'get' + pascal('AllSigningTxRpc');
+    const prefix = camel('all');
+    const aminos = createStargateClientAminoRegistry({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = createStargateClientProtoRegistry({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = createStargateClientOptions({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = createStargateClient({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = createGetTxRpc(ctx, txRpcName, name);
+    }
+    const imports = buildAllImportsFromGenericContext(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = duplicateImportPathsWithExt(importDecls, builder.options.restoreImportExtension);
+    let cProg = importDecls
+        .concat(aminos)
+        .concat(protos)
+        .concat(clientOptions)
+        .concat(clientBody);
+    // replace all backslash path for windows
+    for (let i = 0; i < cProg.length; i++) {
+        if (cProg[i].source?.value) {
+            cProg[i].source.value = toPosixPath(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = join(builder.outPath, clientFile);
+    writeAstToFile(builder.outPath, builder.options, cProg, clientOutFile);
+};

package/module/generators/create-amino-converters.js

@@ -0,0 +1,39 @@
+import { buildAllImports, getDepsFromMutations } from '../imports';
+import { parse } from '../parse';
+export const plugin = (builder, bundler) => {
+    const aminoEncoding = builder.options.aminoEncoding;
+    if (!aminoEncoding?.enabled || !builder.options.rpcClients?.enabled) {
+        return;
+    }
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+    const converters = mutationContexts.map(c => {
+        const aminoEncodingEnabled = c.amino.pluginValue('aminoEncoding.enabled');
+        if (!aminoEncodingEnabled) {
+            return;
+        }
+        const localname = bundler.getLocalFilename(c.ref, 'amino');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        // now let's amino...
+        ctx.buildAminoInterfaces();
+        ctx.buildAminoConverter();
+        const serviceImports = getDepsFromMutations(ctx.mutations, localname);
+        // build file
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addConverters(converters);
+};