@hyperweb/telescope 2.0.4 → 2.2.0

package/module/helpers/internalForBigInt.js

@@ -1,245 +0,0 @@
-export const internalForBigInt = `
-declare var self: any | undefined;
-declare var window: any | undefined;
-declare var global: any | undefined;
-var globalThis: any = (() => {
-  if (typeof globalThis !== 'undefined') return globalThis;
-  if (typeof self !== 'undefined') return self;
-  if (typeof window !== 'undefined') return window;
-  if (typeof global !== 'undefined') return global;
-  throw 'Unable to locate global object';
-})();
-
-const atob: (b64: string) => string =
-  globalThis.atob ||
-  ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
-
-export function bytesFromBase64(b64: string): Uint8Array {
-  const bin = atob(b64);
-  const arr = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; ++i) {
-    arr[i] = bin.charCodeAt(i);
-  }
-  return arr;
-}
-
-const btoa: (bin: string) => string =
-  globalThis.btoa ||
-  ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
-
-export function base64FromBytes(arr: Uint8Array): string {
-  const bin: string[] = [];
-  arr.forEach((byte) => {
-    bin.push(String.fromCharCode(byte));
-  });
-  return btoa(bin.join(''));
-}
-
-export interface AminoHeight {
-  readonly revision_number?: string;
-  readonly revision_height?: string;
-}
-
-export function omitDefault<T extends string | number | bigint>(
-  input: T
-): T | undefined {
-  if (typeof input === 'string') {
-    return input === '' ? undefined : input;
-  }
-
-  if (typeof input === 'number') {
-    return input === 0 ? undefined : input;
-  }
-
-  if (typeof input === 'bigint') {
-    return input === BigInt(0) ? undefined : input;
-  }
-
-  throw new Error(\`Got unsupported type \${typeof input}\`);
-}
-
-interface Duration {
-  /**
-   * Signed seconds of the span of time. Must be from -315,576,000,000
-   * to +315,576,000,000 inclusive. Note: these bounds are computed from:
-   * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-   */
-  seconds: bigint;
-  /**
-   * Signed fractions of a second at nanosecond resolution of the span
-   * of time. Durations less than one second are represented with a 0
-   * \`seconds\` field and a positive or negative \`nanos\` field. For durations
-   * of one second or more, a non-zero value for the \`nanos\` field must be
-   * of the same sign as the \`seconds\` field. Must be from -999,999,999
-   * to +999,999,999 inclusive.
-   */
-
-  nanos: number;
-}
-
-export function toDuration(duration: string): Duration {
-  return {
-    seconds: BigInt(Math.floor(parseInt(duration) / 1000000000)),
-    nanos: parseInt(duration) % 1000000000
-  };
-}
-
-export function fromDuration(duration: Duration): string {
-  return (
-    parseInt(duration.seconds.toString()) * 1000000000 +
-    duration.nanos
-  ).toString();
-}
-
-export function isSet(value: any): boolean {
-  return value !== null && value !== undefined;
-}
-
-export function isObject(value: any): boolean {
-  return typeof value === 'object' && value !== null;
-}
-
-export interface PageRequest {
-  key: Uint8Array;
-  offset: bigint;
-  limit: bigint;
-  countTotal: boolean;
-  reverse: boolean;
-}
-
-export interface PageRequestParams {
-  'pagination.key'?: string;
-  'pagination.offset'?: string;
-  'pagination.limit'?: string;
-  'pagination.count_total'?: boolean;
-  'pagination.reverse'?: boolean;
-}
-
-export interface Params {
-  params: PageRequestParams;
-}
-
-export const setPaginationParams = (
-  options: Params,
-  pagination?: PageRequest
-) => {
-  if (!pagination) {
-    return options;
-  }
-
-  if (typeof pagination?.countTotal !== 'undefined') {
-    options.params['pagination.count_total'] = pagination.countTotal;
-  }
-  if (typeof pagination?.key !== 'undefined') {
-    // String to Uint8Array
-    // let uint8arr = new Uint8Array(Buffer.from(data,'base64'));
-
-    // Uint8Array to String
-    options.params['pagination.key'] = Buffer.from(pagination.key).toString(
-      'base64'
-    );
-  }
-  if (typeof pagination?.limit !== 'undefined') {
-    options.params['pagination.limit'] = pagination.limit.toString();
-  }
-  if (typeof pagination?.offset !== 'undefined') {
-    options.params['pagination.offset'] = pagination.offset.toString();
-  }
-  if (typeof pagination?.reverse !== 'undefined') {
-    options.params['pagination.reverse'] = pagination.reverse;
-  }
-
-  return options;
-};
-
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | bigint
-  | boolean
-  | undefined;
-
-export type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>;
-
-type KeysOfUnion<T> = T extends T ? keyof T : never;
-export type Exact<P, I extends P> = P extends Builtin
-  ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
-        Exclude<keyof I, KeysOfUnion<P>>,
-        never
-      >;
-
-export interface Rpc {
-  request(
-    service: string,
-    method: string,
-    data: Uint8Array
-  ): Promise<Uint8Array>;
-}
-
-interface Timestamp {
-  /**
-   * Represents seconds of UTC time since Unix epoch
-   * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-   * 9999-12-31T23:59:59Z inclusive.
-   */
-  seconds: bigint;
-  /**
-   * Non-negative fractions of a second at nanosecond resolution. Negative
-   * second values with fractions must still have non-negative nanos values
-   * that count forward in time. Must be from 0 to 999,999,999
-   * inclusive.
-   */
-
-  nanos: number;
-}
-
-export function toTimestamp(date: Date): Timestamp {
-  const seconds = numberToLong(date.getTime() / 1_000);
-  const nanos = (date.getTime() % 1000) * 1000000;
-  return {
-    seconds,
-    nanos
-  };
-}
-
-export function fromTimestamp(t: Timestamp): Date {
-  let millis = Number(t.seconds) * 1000;
-  millis += t.nanos / 1000000;
-  return new Date(millis);
-}
-
-const timestampFromJSON = (object: any): Timestamp => {
-  return {
-    seconds: isSet(object.seconds)
-      ? BigInt(object.seconds.toString())
-      : BigInt(0),
-    nanos: isSet(object.nanos) ? Number(object.nanos) : 0
-  };
-};
-
-export function fromJsonTimestamp(o: any): Timestamp {
-  if (o instanceof Date) {
-    return toTimestamp(o);
-  } else if (typeof o === 'string') {
-    return toTimestamp(new Date(o));
-  } else {
-    return timestampFromJSON(o);
-  }
-}
-
-function numberToLong(number: number) {
-  return BigInt(Math.trunc(number));
-}
-`;

package/module/helpers/types.js

@@ -1,21 +0,0 @@
-export const types = `import { BinaryReader, BinaryWriter } from "../../../binary";
-
-/**
- * A type generated by Telescope 1.0.
- */
-export interface TelescopeGeneratedType {
-  readonly typeUrl: string;
-  readonly encode: (
-    message:
-      | any
-      | {
-          [k: string]: any;
-        },
-    writer?: BinaryWriter
-  ) => BinaryWriter;
-  readonly decode: (input: BinaryReader | Uint8Array, length?: number) => any;
-  readonly fromPartial: (object: any) => any;
-}
-
-export type GeneratedType = TelescopeGeneratedType;
-`;

package/module/helpers/vue-query.js

@@ -1,87 +0,0 @@
-export const getVueQueryHelper = (options) => {
-    return `import { getRpcClient } from './extern${options.restoreImportExtension ?? ""}'
-import {
-    useQuery,
-    UseQueryOptions,
-} from '@tanstack/vue-query';
-import { Ref, isRef } from 'vue'
-
-import { HttpEndpoint, ProtobufRpcClient } from '@cosmjs/stargate';
-${options.rpcClients.useConnectComet
-        ? "import { CometClient, connectComet, Tendermint34Client, Tendermint37Client } from '@cosmjs/tendermint-rpc';"
-        : "import { Tendermint34Client } from '@cosmjs/tendermint-rpc';"}
-
-export interface VueQueryParams<TResponse, TData = TResponse> {
-    options?: Omit<UseQueryOptions<TData, Error, TData>, 'queryKey'>;
-}
-
-export interface UseRpcClientQuery<TData> extends VueQueryParams<ProtobufRpcClient, TData> {
-    rpcEndpoint: Ref<string | HttpEndpoint>;
-}
-
-export interface UseRpcEndpointQuery<TData> extends VueQueryParams<string | HttpEndpoint, TData> {
-    getter: () => Promise<string | HttpEndpoint>;
-}
-
-export const useRpcEndpoint = <TData = string | HttpEndpoint>({
-    getter,
-    options,
-}: UseRpcEndpointQuery<TData>) => {
-    return useQuery<string | HttpEndpoint, Error, TData>({
-        queryKey: ['rpcEndpoint', getter],
-        queryFn: async () => {
-            return await getter();
-        },
-        ...options
-    })
-};
-
-export const useRpcClient = <TData = ProtobufRpcClient>({
-    rpcEndpoint,
-    options,
-}: UseRpcClientQuery<TData>) => {
-    let params = {
-		queryKey: ['rpcClient', rpcEndpoint],
-			queryFn: async () => {
-			return await getRpcClient(rpcEndpoint.value);
-		},
-	};
-	if (options && !isRef(options)) {
-		params = {
-			...options,
-			...params,
-		};
-	}
-	return useQuery<ProtobufRpcClient | undefined, Error, TData>(params);
-};
-
-${options.rpcClients.useConnectComet
-        ? "interface UseTendermintClient extends VueQueryParams<Tendermint34Client | Tendermint37Client | CometClient> {"
-        : "interface UseTendermintClient extends VueQueryParams<Tendermint34Client> {"}
-    rpcEndpoint: Ref<string | HttpEndpoint>;
-}
-
-/**
- * Hook that uses vue-query to cache a connected tendermint client.
- */
-export const useTendermintClient = ({
-    rpcEndpoint,
-    options,
-}: UseTendermintClient) => {
-${options.rpcClients.useConnectComet
-        ? "    const { data: client } = useQuery<Tendermint34Client | Tendermint37Client | CometClient, Error, Tendermint34Client | Tendermint37Client | CometClient>("
-        : "    const { data: client } = useQuery<Tendermint34Client, Error, Tendermint34Client>({"}
-        queryKey: ['client', 'tendermint', rpcEndpoint],
-        queryFn: () => ${options.rpcClients.useConnectComet
-        ? "connectComet(rpcEndpoint.value),"
-        : "Tendermint34Client.connect(rpcEndpoint.value),"}
-		// allow overriding
-		throwOnError: (e) => {
-			throw new Error(\`Failed to connect to \${rpcEndpoint}\` + '\\n' + e)
-		},
-		...options,
-    })
-    return { client }
-};
-`;
-};

package/module/protod/proto-download.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-import { clone, extractProto } from "./recursive";
-import { removeFolder } from "./utils";
-async function run() {
-    const argv = process.argv.slice(2);
-    const gitRepoIndex = argv.findIndex((arg) => arg === "--git-repo");
-    if (gitRepoIndex === -1) {
-        process.stderr.write("`git-repo` is not specified");
-        process.exit(1);
-    }
-    const [owner, repo] = argv[gitRepoIndex + 1]?.split("/");
-    if (!owner || !repo) {
-        process.stderr.write("wrong `git-repo` format (i.e. <owner>/<repository>).");
-        process.exit(1);
-    }
-    const targetsIndex = argv.findIndex((arg) => arg === "--targets");
-    if (targetsIndex === -1) {
-        process.stdout.write("`targets` is not specified");
-        process.exit(1);
-    }
-    const targets = argv[targetsIndex + 1]?.split(",");
-    if (!targets || targets.length === 0) {
-        process.stderr.write("wrong `targets` format (i.e. <**/*.proto>,<**/*.proto>,<**/*.proto>).");
-        process.exit(1);
-    }
-    const outDirIndex = argv.findIndex((arg) => arg === "--out");
-    if (outDirIndex === -1) {
-        process.stdout.write("`out` is not specified, downloading to `proto` folder by default.\n");
-    }
-    const outDir = outDirIndex !== -1 ? argv[outDirIndex + 1] : "./proto";
-    const omitCloneIndex = argv.findIndex((arg) => arg === "--omit-clone");
-    let omitClone = false;
-    if (omitCloneIndex !== -1 && argv[omitCloneIndex + 1] === "true") {
-        omitClone = true;
-    }
-    if (omitCloneIndex !== -1 &&
-        typeof argv[omitCloneIndex + 1] === "undefined") {
-        omitClone = true;
-    }
-    removeFolder("git-modules");
-    const result = await clone({
-        owner,
-        repo,
-        outDir: "./git-modules",
-    });
-    if (result) {
-        removeFolder(outDir);
-        extractProto({
-            sources: result,
-            targets,
-            outDir,
-        });
-    }
-}
-run();

package/module/telescope.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import { cli } from './cli';
-var argv = require('minimist')(process.argv.slice(2), {
-    boolean: ['ssh']
-});
-(async () => {
-    await cli(argv);
-})();

package/module/utils/contracts.js

@@ -1,33 +0,0 @@
-import { readSchemas } from '@cosmwasm/ts-codegen';
-import { pascal } from 'case';
-import { basename, dirname, join } from 'path';
-import { readFileSync, readdirSync } from 'fs';
-export const getDirectories = source => readdirSync(source, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
-    .map(dirent => dirent.name);
-export const getContracts = () => {
-    const contracts = getDirectories('./contracts')
-        .map(contractDirname => {
-        return {
-            name: `${contractDirname}`,
-            value: `./contracts/${contractDirname}`
-        };
-    });
-    return contracts;
-};
-export const getContractSchemata = async (schemata, out, argv) => {
-    const s = [];
-    for (let i = 0; i < schemata.length; i++) {
-        const path = schemata[i];
-        const pkg = JSON.parse(readFileSync(join(path, 'package.json'), 'utf-8'));
-        const name = basename(path);
-        const folder = basename(dirname(path));
-        const contractName = pascal(pkg.contract) || pascal(name);
-        const schemas = await readSchemas({ schemaDir: path });
-        const outPath = join(out, folder);
-        s.push({
-            contractName, schemas, outPath
-        });
-    }
-    return s;
-};

package/src/build.ts

@@ -1,255 +0,0 @@
-import { ProtoRef, TelescopeOptions } from '@cosmology/types';
-import { ProtoStore } from '@cosmology/proto-parser';
-import {
-    AminoParseContext,
-    createAminoConverter,
-    createCreateProtoType,
-    createObjectWithMethods,
-    createRegisterObject,
-    createProtoEnum,
-    createProtoEnumToJSON,
-    createProtoEnumFromJSON,
-    createProtoType,
-    createProtoInterfaceEncodedType,
-    createProtoTypeType,
-    createSDKType,
-    createAminoType,
-    createAminoTypeType,
-    createEnumSDKType,
-    createEnumAminoType,
-    makeAminoTypeInterface,
-    GenericParseContext,
-    ProtoParseContext,
-    createTypeRegistry,
-    createRegistryLoader,
-
-    // helper
-    createHelperObject,
-    createInterfaceDecoder,
-    createInterfaceFromAmino,
-    createInterfaceToAmino,
-    createRegisterAminoProtoMapping,
-} from '@cosmology/ast';
-import { ServiceMutation, ServiceQuery } from '@cosmology/types';
-
-export const getMutations = (mutations: ServiceMutation[]) => {
-    return mutations.map((mutation: ServiceMutation) => {
-        return {
-            typeUrl: `/${mutation.package}.${mutation.message}`,
-            TypeName: mutation.message,
-            methodName: mutation.methodName
-        }
-    });
-};
-
-export const getAminoProtos = (mutations: ServiceMutation[], store: ProtoStore) => {
-    return mutations.map(mutation => {
-        const ref = store.findProto(mutation.messageImport);
-        return store.get(ref, mutation.message).obj;
-    });
-};
-
-export const buildBaseTypeScriptClass = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-    if (context.options.prototypes.enabled) {
-        context.body.push(createCreateProtoType(context.proto, name, obj));
-        context.body.push(createObjectWithMethods(context.proto, name, obj));
-
-        if(context.options.interfaces?.enabled && context.options.interfaces?.useGlobalDecoderRegistry && context.options.interfaces?.registerAllDecodersToGlobal){
-          const registerObj = createRegisterObject(context.proto, name, obj);
-          if(registerObj){
-            context.body.push(registerObj);
-
-            //createRegisterAminoProtoMapping
-            const registerAminoObj = createRegisterAminoProtoMapping(context.proto, name, obj);
-            if(registerAminoObj){
-              context.body.push(registerAminoObj);
-            }
-          }
-        }
-    }
-};
-
-export const buildBaseTypeScriptInterface = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-
-    context.body.push(createProtoType(context.proto, name, obj));
-
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding || context.options.prototypes?.methods?.fromProto || context.options.prototypes?.methods?.toProto) {
-        context.body.push(createProtoTypeType(context.proto, name, obj));
-    }
-
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
-        // conditional type
-        const interfaceType = createProtoInterfaceEncodedType(context.proto, name, obj);
-        if (interfaceType) {
-            context.body.push(interfaceType);
-        }
-        context.body.push(createAminoType(context.proto, name, obj));
-
-        if(!context.options.aminoEncoding?.disableMsgTypes){
-            context.body.push(createAminoTypeType(context.proto, name, obj));
-        }
-    }
-    if (context.options.useSDKTypes) {
-        context.body.push(createSDKType(context.proto, name, obj));
-    }
-};
-
-export const buildEnums = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-    context.body.push(createProtoEnum(context.proto, name, obj));
-    if (context.options.useSDKTypes) {
-        context.body.push(createEnumSDKType(context.proto, name, obj));
-    }
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
-        context.body.push(createEnumAminoType(context.proto, name, obj));
-    }
-    context.body.push(createProtoEnumFromJSON(context.proto, name, obj));
-    context.body.push(createProtoEnumToJSON(context.proto, name, obj));
-};
-export interface TelescopeParseContext {
-    options: TelescopeOptions;
-    generic: GenericParseContext;
-    proto: ProtoParseContext;
-    amino: AminoParseContext;
-    store: ProtoStore;
-    ref: ProtoRef;
-    parsedImports: Record<string, any>;
-    body: any[];
-    mutations: ServiceMutation[];
-    queries: any[];
-    services: any[];
-    types: any[];
-}
-export class TelescopeParseContext implements TelescopeParseContext {
-    constructor(ref: ProtoRef, store: ProtoStore, options: TelescopeOptions) {
-        this.generic = new GenericParseContext(
-            ref, store, options
-        );
-        this.proto = new ProtoParseContext(
-            ref, store, options
-        );
-        this.amino = new AminoParseContext(
-            ref, store, options
-        );
-        this.options = options;
-        this.ref = ref;
-        this.store = store;
-        this.parsedImports = {};
-        this.body = [];
-        this.queries = [];
-        this.services = [];
-        this.mutations = [];
-        this.types = [];
-    }
-
-    hasMutations() {
-        return this.mutations.length > 0;
-    }
-
-    addType(name: string, obj: any, isNested: boolean) {
-        this.types.push({
-            name,
-            obj,
-            isNested
-        });
-    }
-    addMutation(mutation: ServiceMutation) {
-        this.mutations.push(mutation);
-    }
-    addQuery(query: ServiceQuery) {
-        this.queries.push(query);
-    }
-    addService(query: any) {
-        this.services.push(query);
-    }
-    // build main Class with methods
-    buildBase() {
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Enum') {
-                buildEnums(this, name, obj);
-            }
-        });
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Type') {
-                buildBaseTypeScriptInterface(this, name, obj);
-            }
-        });
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Type') {
-                buildBaseTypeScriptClass(this, name, obj);
-            }
-        });
-
-        // interfaces
-        if (this.options.interfaces.enabled && !this.options.interfaces.useGlobalDecoderRegistry) {
-            const interfaces = Object.keys(this.ref.traversed.acceptsInterface ?? {});
-            if (interfaces.length) {
-                interfaces.forEach(interfaceName => {
-                    this.body.push(createInterfaceDecoder(this.proto, this.ref, interfaceName));
-                    if (
-                        this.options.aminoEncoding?.enabled &&
-                        !this.options.aminoEncoding?.useLegacyInlineEncoding
-                    ) {
-                        this.body.push(createInterfaceFromAmino(this.proto, this.ref, interfaceName));
-                        this.body.push(createInterfaceToAmino(this.proto, this.ref, interfaceName));
-                    }
-                })
-            }
-        }
-    }
-
-    buildRegistry() {
-        this.body.push(createTypeRegistry(this.amino, getMutations(this.mutations)));
-    }
-    buildRegistryLoader() {
-        if (!this.options?.prototypes?.enableRegistryLoader) {
-          return
-        }
-
-        this.body.push(createRegistryLoader(this.amino));
-    }
-    buildAminoInterfaces() {
-        if (!this.options?.aminoEncoding?.enabled || !this.options?.aminoEncoding?.useLegacyInlineEncoding) return;
-        //
-        const protos = getAminoProtos(this.mutations, this.store);
-        protos.forEach(proto => {
-            this.body.push(makeAminoTypeInterface({
-                context: this.amino,
-                proto
-            }));
-        });
-    }
-    buildAminoConverter() {
-        this.body.push(createAminoConverter({
-            name: 'AminoConverter',
-            context: this.amino,
-            root: this.ref.traversed,
-            protos: getAminoProtos(this.mutations, this.store)
-        }));
-    }
-    buildHelperObject() {
-        if (!this.options?.prototypes?.enableMessageComposer) {
-          return
-        }
-        // add methods
-        this.body.push(createHelperObject({
-            context: this.amino,
-            name: 'MessageComposer',
-            mutations: getMutations(this.mutations)
-        }));
-    }
-}