@hyperweb/telescope 1.15.0

package/main/generators/create-stargate-clients.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const case_1 = require("case");
+const utils_1 = require("@cosmology/utils");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: bundler.bundle.base,
+            root: {},
+        }
+    };
+    const ctx = new ast_1.GenericParseContext(ctxRef, null, builder.options);
+    const stargateClientsEnabled = ctx.pluginValue("stargateClients.enabled");
+    if (!stargateClientsEnabled || !bundler.registries || !bundler.registries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = (0, path_1.join)(`${bundler.bundle.base}`, 'client.ts');
+    bundler.files.push(clientFile);
+    const registryVariables = [];
+    const converterVariables = [];
+    bundler.registries.forEach(registry => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    bundler.converters.forEach(converter => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    const name = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'Client');
+    const txRpcName = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'TxRpc');
+    const prefix = (0, case_1.camel)(bundler.bundle.base);
+    const aminos = (0, ast_1.createStargateClientAminoRegistry)({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = (0, ast_1.createStargateClientProtoRegistry)({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = (0, ast_1.createStargateClientOptions)({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = (0, ast_1.createStargateClient)({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = (0, ast_1.createGetTxRpc)(ctx, txRpcName, name);
+    }
+    const imports = (0, imports_1.buildAllImportsFromGenericContext)(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = (0, utils_1.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 = (0, utils_1.toPosixPath)(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = (0, path_1.join)(builder.outPath, clientFile);
+    bundler.writeAst(cProg, clientOutFile);
+};
+exports.plugin = plugin;

package/main/generators/create-types.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const t = __importStar(require("@babel/types"));
+const imports_1 = require("../imports");
+const parse_1 = require("../parse");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("@cosmology/utils");
+const files_1 = require("../utils/files");
+const plugin = (builder, bundler) => {
+    const instantRpcBundlerFiles = {};
+    // [x] search for all files that live in package
+    const baseProtos = builder.store.getProtos().filter((ref) => {
+        return ref.proto.package.split(".")[0] === bundler.bundle.base;
+    });
+    // [x] write out all TS files for package
+    bundler.contexts = baseProtos
+        .map((ref) => {
+        const context = builder.context(ref);
+        (0, parse_1.parse)(context);
+        context.buildBase();
+        const allTypes = context.types.filter((type) => type.obj.type === "Enum" || type.obj.type === "Type");
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter((a) => a !== "Msg");
+        const localname = bundler.getLocalFilename(ref);
+        const filename = bundler.getFilename(localname);
+        const bundlerFile = {
+            proto: context.ref.filename,
+            package: context.ref.proto.package,
+            localname,
+            filename,
+        };
+        if (context.proto.pluginValue("rpcClients.inline")) {
+            const proto = (0, proto_parser_1.getNestedProto)(context.ref.traversed);
+            const instantOps = context.options.rpcClients?.instantOps ?? [];
+            const useCamelCase = context.options.rpcClients?.camelCase;
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    const svc = proto[svcKey];
+                    context.body.push((0, ast_1.createRpcClientInterface)(context.generic, proto[svcKey]));
+                    instantOps.forEach((item) => {
+                        let nameMapping = {
+                            ...(0, utils_1.swapKeyValue)(item.nameMapping?.All ?? {}),
+                            ...(0, utils_1.swapKeyValue)(item.nameMapping?.Query ?? {}),
+                        };
+                        // get all query methods
+                        const patterns = item.include?.patterns;
+                        const serviceTypes = item.include?.serviceTypes;
+                        if (serviceTypes && !serviceTypes.includes("Query")) {
+                            return;
+                        }
+                        const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns, useCamelCase ? utils_1.camel : String);
+                        if (!methodKeys || !methodKeys.length) {
+                            return;
+                        }
+                        context.body.push((0, ast_1.createRpcClientInterface)(context.generic, svc, item.className, methodKeys, nameMapping));
+                        bundlerFile.instantExportedMethods = methodKeys.map((key) => proto[svcKey].methods[key]);
+                        if (!instantRpcBundlerFiles[item.className]) {
+                            instantRpcBundlerFiles[item.className] = [];
+                        }
+                        instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                    });
+                    context.body.push((0, ast_1.createRpcClientClass)(context.generic, proto[svcKey]));
+                    if (context.proto.pluginValue("rpcClients.extensions")) {
+                        context.body.push((0, ast_1.createRpcQueryExtension)(context.generic, proto[svcKey]));
+                    }
+                    else {
+                        const env = context.proto.pluginValue("env");
+                        if (env === "v-next") {
+                            context.body.push((0, ast_1.createRpcClientImpl)(context.generic, proto[svcKey]));
+                        }
+                    }
+                }
+            });
+            if (proto.Msg) {
+                bundlerFile.isMsg = true;
+                context.body.push((0, ast_1.createRpcClientInterface)(context.generic, proto.Msg));
+                instantOps.forEach((item) => {
+                    let nameMapping = {
+                        ...(0, utils_1.swapKeyValue)(item.nameMapping?.All ?? {}),
+                        ...(0, utils_1.swapKeyValue)(item.nameMapping?.Msg ?? {}),
+                    };
+                    // get all msg methods
+                    const patterns = item.include?.patterns;
+                    const serviceTypes = item.include?.serviceTypes;
+                    if (serviceTypes && !serviceTypes.includes("Tx")) {
+                        return;
+                    }
+                    const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto.Msg.methods ?? {}), patterns, useCamelCase ? utils_1.camel : String);
+                    if (!methodKeys || !methodKeys.length) {
+                        return;
+                    }
+                    context.body.push((0, ast_1.createRpcClientInterface)(context.generic, proto.Msg, item.className, methodKeys, nameMapping));
+                    bundlerFile.instantExportedMethods = methodKeys.map((key) => proto["Msg"].methods[key]);
+                    if (!instantRpcBundlerFiles[item.className]) {
+                        instantRpcBundlerFiles[item.className] = [];
+                    }
+                    instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                });
+                context.body.push((0, ast_1.createRpcClientClass)(context.generic, proto.Msg));
+                const env = context.proto.pluginValue("env");
+                if (env === "v-next") {
+                    context.body.push((0, ast_1.createRpcClientImpl)(context.generic, proto.Msg));
+                }
+            }
+        }
+        // build BASE file
+        const importStmts = (0, imports_1.buildAllImports)(context, null, context.ref.filename);
+        const prog = [].concat(importStmts);
+        // package var
+        if (context.proto.pluginValue("prototypes.includePackageVar")) {
+            prog.push(t.exportNamedDeclaration(t.variableDeclaration("const", [
+                t.variableDeclarator(t.identifier("protobufPackage"), t.stringLiteral(context.ref.proto.package)),
+            ])));
+        }
+        // body
+        prog.push.apply(prog, context.body);
+        if (context.body.length > 0) {
+            const exportedTypeNames = (0, files_1.getExportedTypeNames)(prog);
+            exportedTypeNames.forEach((name) => {
+                context.store.setTypeFilesMapping(name, localname);
+            });
+            bundler.writeAst(prog, filename);
+            bundler.addExportObjToBundle(context.ref.proto.package, localname, exportedTypeNames);
+        }
+        else {
+            mkdirp_1.mkdirp.sync((0, path_1.dirname)(filename));
+            (0, fs_1.writeFileSync)(filename, `export {}`);
+        }
+        return context;
+    })
+        .filter(Boolean);
+    Object.keys(instantRpcBundlerFiles).forEach((className) => {
+        bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    });
+};
+exports.plugin = plugin;

package/main/generators/customize-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const utils_1 = require("../utils");
+const plugin = (builder) => {
+    if (builder.options.useInterchainJs) {
+        utils_1.UTILS.encodePubkey = '@interchainjs/pubkey';
+        utils_1.UTILS.decodePubkey = '@interchainjs/pubkey';
+        utils_1.UTILS.fromBase64 = '@interchainjs/encoding';
+        utils_1.UTILS.fromBech32 = '@interchainjs/encoding';
+        utils_1.UTILS.fromHex = '@interchainjs/encoding';
+        utils_1.UTILS.fromUtf8 = '@interchainjs/encoding';
+        utils_1.UTILS.toBase64 = '@interchainjs/encoding';
+        utils_1.UTILS.toUtf8 = '@interchainjs/encoding';
+        utils_1.UTILS.Decimal = '@interchainjs/math';
+        utils_1.UTILS.DeliverTxResponse = '@interchainjs/types';
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal ===
+        true) {
+        utils_1.UTILS.Decimal = '__decimals__';
+    }
+    else {
+        if (builder.options.useInterchainJs) {
+            utils_1.UTILS.Decimal = '@interchainjs/math';
+        }
+        else {
+            utils_1.UTILS.Decimal = '@cosmjs/math';
+        }
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.base64Lib ===
+        '@endo/base64') {
+        utils_1.UTILS.base64FromBytes = {
+            type: 'import',
+            path: '@endo/base64',
+            name: 'encodeBase64',
+            importAs: 'base64FromBytes',
+        };
+        utils_1.UTILS.bytesFromBase64 = {
+            type: 'import',
+            path: '@endo/base64',
+            name: 'decodeBase64',
+            importAs: 'bytesFromBase64',
+        };
+    }
+    else {
+        utils_1.UTILS.base64FromBytes = '__helpers__';
+        utils_1.UTILS.bytesFromBase64 = '__helpers__';
+    }
+};
+exports.plugin = plugin;

package/main/helpers/__test__/internalTimestamp.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJsonTimestamp = exports.fromTimestamp = exports.toTimestamp = exports.isSet = void 0;
+const long_1 = __importDefault(require("long"));
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+exports.isSet = isSet;
+function toTimestamp(date) {
+    const seconds = numberToLong(date.getTime() / 1_000);
+    const nanos = date.getTime() % 1000 * 1000000;
+    return {
+        seconds,
+        nanos
+    };
+}
+exports.toTimestamp = toTimestamp;
+;
+function fromTimestamp(t) {
+    let millis = t.seconds.toNumber() * 1000;
+    millis += t.nanos / 1000000;
+    return new Date(millis);
+}
+exports.fromTimestamp = fromTimestamp;
+;
+const timestampFromJSON = (object) => {
+    return {
+        seconds: isSet(object.seconds) ? long_1.default.fromValue(object.seconds) : long_1.default.ZERO,
+        nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+    };
+};
+function fromJsonTimestamp(o) {
+    if (o instanceof Date) {
+        return toTimestamp(o);
+    }
+    else if (typeof o === "string") {
+        return toTimestamp(new Date(o));
+    }
+    else {
+        return timestampFromJSON(o);
+    }
+}
+exports.fromJsonTimestamp = fromJsonTimestamp;
+function numberToLong(number) {
+    return long_1.default.fromNumber(number);
+}

package/main/helpers/__test__/internalTimestampBigint.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJsonTimestamp = exports.fromTimestamp = exports.toTimestamp = exports.isSet = void 0;
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+exports.isSet = isSet;
+function toTimestamp(date) {
+    const seconds = numberToLong(date.getTime() / 1_000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return {
+        seconds,
+        nanos
+    };
+}
+exports.toTimestamp = toTimestamp;
+function fromTimestamp(t) {
+    let millis = Number(t.seconds) * 1000;
+    millis += t.nanos / 1000000;
+    return new Date(millis);
+}
+exports.fromTimestamp = fromTimestamp;
+const timestampFromJSON = (object) => {
+    return {
+        seconds: isSet(object.seconds)
+            ? BigInt(object.seconds.toString())
+            : BigInt(0),
+        nanos: isSet(object.nanos) ? Number(object.nanos) : 0
+    };
+};
+function fromJsonTimestamp(o) {
+    if (o instanceof Date) {
+        return toTimestamp(o);
+    }
+    else if (typeof o === 'string') {
+        return toTimestamp(new Date(o));
+    }
+    else {
+        return timestampFromJSON(o);
+    }
+}
+exports.fromJsonTimestamp = fromJsonTimestamp;
+function numberToLong(number) {
+    return BigInt(Math.trunc(number));
+}