@hyperweb/telescope 1.15.0

package/src/contracts/install.ts

@@ -0,0 +1,118 @@
+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/src/contracts/message-composer.ts

@@ -0,0 +1,34 @@
+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/src/contracts/react-query.ts

@@ -0,0 +1,33 @@
+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/src/contracts/recoil.ts

@@ -0,0 +1,32 @@
+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/src/file.js

@@ -0,0 +1,20 @@
+#!/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/src/generators/create-aggregated-lcd-client.ts

@@ -0,0 +1,133 @@
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+import { getNestedProto, isRefIncluded, isRefExcluded } from '@cosmology/proto-parser';
+import { parse } from '../parse';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { createAggregatedLCDClient } from '@cosmology/ast';
+import { ALLOWED_RPC_SERVICES, ProtoRef, ProtoService } from '@cosmology/types';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { fixlocalpaths } from '../utils';
+
+export const plugin = (
+    builder: TelescopeBuilder
+) => {
+
+    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: ProtoRef) => {
+        return isRefIncluded(ref, {
+            packages,
+            protos
+        }) && !isRefExcluded(ref, builder.options.prototypes?.excluded);
+    });
+
+    const services: ProtoService[] = 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/src/generators/create-all-stargate-clients.ts

@@ -0,0 +1,121 @@
+import { Bundler } from '../bundler';
+import { TelescopeBuilder } from '../builder';
+import { join, dirname, relative } from 'path';
+import {
+    importNamespace,
+    GenericParseContext,
+    createStargateClient,
+    createStargateClientOptions,
+    createStargateClientProtoRegistry,
+    createStargateClientAminoRegistry,
+    createGetTxRpc
+} from '@cosmology/ast';
+import { ProtoRef } from '@cosmology/types';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+import { writeAstToFile } from '../utils/files';
+import { BundlerFile } from '../types';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    allRegistries: BundlerFile[],
+    allConverters: BundlerFile[]
+) => {
+
+    if (!allRegistries || !allRegistries.length) {
+        return;
+    }
+
+    const registryImports = [];
+    const converterImports = [];
+
+    const clientFile = 'all-module-client.ts'
+    builder.files.push(clientFile);
+    const ctxRef: ProtoRef = {
+        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/src/generators/create-amino-converters.ts

@@ -0,0 +1,62 @@
+import { buildAllImports, getDepsFromMutations } from '../imports';
+import { Bundler } from '../bundler';
+import { parse } from '../parse';
+import { TelescopeBuilder } from '../builder';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: 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);
+};

package/src/generators/create-bundle.ts

@@ -0,0 +1,97 @@
+import { Bundler } from "../bundler";
+import { TelescopeBuilder } from "../builder";
+import {
+  exportAllFromRelPath,
+  exportTypesWithAlias,
+  recursiveModuleBundle,
+} from "@cosmology/ast";
+import { duplicateImportPathsWithExt, makeAliasName, makeAliasNameWithPackageAtEnd } from "@cosmology/utils";
+
+export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
+  if (!builder.options.bundle.enabled) {
+    return;
+  }
+
+  let prog = [];
+
+  if (builder.options.bundle.type === "namespace") {
+    const importPaths = duplicateImportPathsWithExt(
+      bundler.bundle.importPaths,
+      builder.options.restoreImportExtension
+    );
+
+    // [x] bundle
+    const body = recursiveModuleBundle(
+      builder.options,
+      bundler.bundle.bundleVariables
+    );
+    prog = prog.concat(importPaths).concat(body);
+  } else if (builder.options.bundle.type === "module") {
+    // get export objs
+    const exportObjs = bundler.bundle.exportObjs;
+    if (!exportObjs) {
+      return;
+    }
+
+    // check each of exported identifiers is duplicated
+    exportObjs.forEach((exportObj) => {
+      const duplicatedTypeNames = exportObj.exportedIdentifiers.filter(
+        (identifier) => {
+          let isDuplicated = false;
+          if (exportObj.isHelperFunc) {
+            const duplicatedHelperFuncs =
+              builder.store.getHelperFuncsInMultipleFiles();
+
+            isDuplicated = duplicatedHelperFuncs.some((helperFunc) => {
+              return helperFunc === identifier;
+            });
+          } else {
+            const duplicatedTypes = builder.store.getTypesInMultipleFiles();
+            isDuplicated = duplicatedTypes.some((type) => {
+              return type === identifier;
+            });
+          }
+          return isDuplicated;
+        }
+      );
+      if (duplicatedTypeNames.length > 0) {
+        // export each, some duplicated with alias
+        const typesWithAlias = exportObj.exportedIdentifiers.map((identifier) => {
+          const duplicatedType = duplicatedTypeNames.find((type) => type === identifier);
+          if (duplicatedType) {
+            let alias: string;
+            if (exportObj.isHelperFunc) {
+              const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+              if (serialNumber > 0) {
+                alias = makeAliasNameWithPackageAtEnd({ package: exportObj.pkg, name: identifier });
+              } else {
+                alias = identifier;
+              }
+            } else {
+              const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+              if (serialNumber > 0) {
+                alias = makeAliasName({ package: exportObj.pkg, name: identifier });
+              } else {
+                alias = identifier;
+              }
+            }
+            return { name: identifier, alias: alias };
+          }
+          return { name: identifier, alias: identifier };
+        });
+        prog.push(exportTypesWithAlias(typesWithAlias, exportObj.relativePath));
+      } else {
+        // export *
+        prog.push(exportAllFromRelPath(exportObj.relativePath));
+      }
+    });
+  }
+
+  const localname = bundler.bundle.bundleFile;
+  const filename = bundler.getFilename(localname);
+
+  bundler.writeAst(prog, filename);
+
+  // [x] write an index file for each base
+  bundler.files.forEach((file) => builder.files.push(file));
+};

package/src/generators/create-cosmwasm-bundle.ts

@@ -0,0 +1,17 @@
+import { TelescopeBuilder } from '../builder';
+import { TSBuilder } from '@cosmwasm/ts-codegen';
+
+export const plugin = async (
+    builder: TelescopeBuilder
+) => {
+
+    if (!builder.options.cosmwasm) {
+        return;
+    }
+
+    const input = builder.options.cosmwasm;
+    const cosmWasmBuilder = new TSBuilder(input);
+    await cosmWasmBuilder.build();
+    const file = input.options.bundle.bundleFile;
+    builder.files.push(file);
+};