@hyperweb/telescope 1.15.0

package/src/generators/create-types.ts

@@ -0,0 +1,236 @@
+import * as t from "@babel/types";
+import { Bundler } from "../bundler";
+import { TelescopeBuilder } from "../builder";
+import { buildAllImports } from "../imports";
+import { parse } from "../parse";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import { mkdirp } from "mkdirp";
+import { getNestedProto, isRefExcluded } from "@cosmology/proto-parser";
+import {
+  createRpcClientClass,
+  createRpcClientImpl,
+  createRpcClientInterface,
+  createRpcQueryExtension,
+} from "@cosmology/ast";
+import { BundlerFile } from "src/types";
+import { camel, getQueryMethodNames, swapKeyValue } from "@cosmology/utils";
+import { getExportedTypeNames } from "../utils/files";
+
+export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
+  const instantRpcBundlerFiles: {
+    [key: string]: BundlerFile[];
+  } = {};
+
+  // [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);
+
+      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: BundlerFile = {
+        proto: context.ref.filename,
+        package: context.ref.proto.package,
+        localname,
+        filename,
+      };
+
+      if (context.proto.pluginValue("rpcClients.inline")) {
+        const proto = 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(
+              createRpcClientInterface(context.generic, proto[svcKey])
+            );
+
+            instantOps.forEach((item) => {
+              let nameMapping = {
+                ...swapKeyValue(item.nameMapping?.All ?? {}),
+                ...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 = getQueryMethodNames(
+                bundlerFile.package,
+                Object.keys(proto[svcKey].methods ?? {}),
+                patterns,
+                useCamelCase ? camel : String
+              );
+
+              if (!methodKeys || !methodKeys.length) {
+                return;
+              }
+
+              context.body.push(
+                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(
+              createRpcClientClass(context.generic, proto[svcKey])
+            );
+            if (context.proto.pluginValue("rpcClients.extensions")) {
+              context.body.push(
+                createRpcQueryExtension(context.generic, proto[svcKey])
+              );
+            } else {
+              const env = context.proto.pluginValue("env");
+              if (env === "v-next") {
+                context.body.push(
+                  createRpcClientImpl(context.generic, proto[svcKey])
+                );
+              }
+            }
+          }
+        });
+
+        if (proto.Msg) {
+          bundlerFile.isMsg = true;
+          context.body.push(
+            createRpcClientInterface(context.generic, proto.Msg)
+          );
+
+          instantOps.forEach((item) => {
+            let nameMapping = {
+              ...swapKeyValue(item.nameMapping?.All ?? {}),
+              ...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 = getQueryMethodNames(
+              bundlerFile.package,
+              Object.keys(proto.Msg.methods ?? {}),
+              patterns,
+              useCamelCase ? camel : String
+            );
+
+            if (!methodKeys || !methodKeys.length) {
+              return;
+            }
+
+            context.body.push(
+              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(createRpcClientClass(context.generic, proto.Msg));
+          const env = context.proto.pluginValue("env");
+          if (env === "v-next") {
+            context.body.push(createRpcClientImpl(context.generic, proto.Msg));
+          }
+        }
+      }
+
+      // build BASE file
+      const importStmts = 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 = getExportedTypeNames(prog);
+
+        exportedTypeNames.forEach((name) => {
+          context.store.setTypeFilesMapping(name, localname);
+        });
+
+        bundler.writeAst(prog, filename);
+        bundler.addExportObjToBundle(context.ref.proto.package, localname, exportedTypeNames);
+      } else {
+        mkdirp.sync(dirname(filename));
+        writeFileSync(filename, `export {}`);
+      }
+
+      return context;
+    })
+    .filter(Boolean);
+
+  Object.keys(instantRpcBundlerFiles).forEach((className) => {
+    bundler.addStateManagers(
+      `instantRpc_${className}`,
+      instantRpcBundlerFiles[className]
+    );
+  });
+};

package/src/generators/customize-utils.ts

@@ -0,0 +1,54 @@
+import { TelescopeBuilder } from '../builder';
+import { UTILS } from '../utils';
+
+export const plugin = (builder: TelescopeBuilder) => {
+  if(builder.options.useInterchainJs) {
+    UTILS.encodePubkey = '@interchainjs/pubkey';
+    UTILS.decodePubkey = '@interchainjs/pubkey';
+
+    UTILS.fromBase64 = '@interchainjs/encoding';
+    UTILS.fromBech32 = '@interchainjs/encoding';
+    UTILS.fromHex = '@interchainjs/encoding';
+    UTILS.fromUtf8 = '@interchainjs/encoding';
+    UTILS.toBase64 = '@interchainjs/encoding';
+    UTILS.toUtf8 = '@interchainjs/encoding';
+
+    UTILS.Decimal = '@interchainjs/math';
+
+    UTILS.DeliverTxResponse = '@interchainjs/types';
+  }
+
+  if (
+    builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal ===
+    true
+  ) {
+    UTILS.Decimal = '__decimals__';
+  } else {
+    if (builder.options.useInterchainJs) {
+      UTILS.Decimal = '@interchainjs/math';
+    } else {
+      UTILS.Decimal = '@cosmjs/math';
+    }
+  }
+
+  if (
+    builder.options.prototypes.typingsFormat.customTypes.base64Lib ===
+    '@endo/base64'
+  ) {
+    UTILS.base64FromBytes = {
+      type: 'import',
+      path: '@endo/base64',
+      name: 'encodeBase64',
+      importAs: 'base64FromBytes',
+    };
+    UTILS.bytesFromBase64 = {
+      type: 'import',
+      path: '@endo/base64',
+      name: 'decodeBase64',
+      importAs: 'bytesFromBase64',
+    };
+  } else {
+    UTILS.base64FromBytes = '__helpers__';
+    UTILS.bytesFromBase64 = '__helpers__';
+  }
+};

package/src/helpers/__test__/internalTimestamp.test.ts

@@ -0,0 +1,79 @@
+import {
+  toTimestamp,
+  fromTimestamp,
+  fromJsonTimestamp,
+} from "./internalTimestamp";
+import Long from "long";
+
+describe("Timestamp Utilities", () => {
+  describe("toTimestamp", () => {
+    it("should convert a date to a Timestamp", () => {
+      const date = new Date("2000-01-01T00:00:00Z");
+      const result = toTimestamp(date);
+      expect(result.seconds.equals(Long.fromNumber(946684800))).toBeTruthy(); // 2000-01-01T00:00:00Z in Unix time
+      expect(result.nanos).toBe(0);
+    });
+
+    it("should handle nanosecond conversion correctly", () => {
+      const date = new Date(946684800001); // 1 millisecond after 2000-01-01T00:00:00Z
+      const result = toTimestamp(date);
+      expect(result.seconds.equals(Long.fromNumber(946684800))).toBeTruthy();
+      expect(result.nanos).toBe(1000000); // 1 millisecond is 1,000,000 nanoseconds
+    });
+  });
+
+  describe("fromTimestamp", () => {
+    it("should convert a Timestamp to a date", () => {
+      const timestamp = { seconds: Long.fromNumber(946684800), nanos: 0 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(946684800000); // 2000-01-01T00:00:00Z in Unix time
+    });
+
+    it("should handle nanosecond conversion correctly", () => {
+      const timestamp = { seconds: Long.fromNumber(946684800), nanos: 1000000 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(946684800001); // 1 millisecond after 2000-01-01T00:00:00Z
+    });
+
+    it("should handle negative seconds with positive nanoseconds", () => {
+      const timestamp = { seconds: Long.fromNumber(-1), nanos: 1000000 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(-999); // 1 millisecond before 1970-01-01T00:00:00Z
+    });
+  });
+
+  describe("fromJsonTimestamp", () => {
+    it("should convert a Date object to a Timestamp", () => {
+      const date = new Date("2000-01-01T00:00:00Z");
+      const result = fromJsonTimestamp(date);
+      const expected = toTimestamp(date);
+      expect(result.seconds.equals(expected.seconds)).toBeTruthy();
+      expect(result.nanos).toBe(expected.nanos);
+    });
+
+    it("should convert a string date to a Timestamp", () => {
+      const dateString = "2000-01-01T00:00:00Z";
+      const result = fromJsonTimestamp(dateString);
+      const expected = toTimestamp(new Date(dateString));
+      expect(result.seconds.equals(expected.seconds)).toBeTruthy();
+      expect(result.nanos).toBe(expected.nanos);
+    });
+
+    it("should convert a JSON object to a Timestamp", () => {
+      const json = {
+        seconds: "946684800",
+        nanos: "1000000",
+      };
+      const result = fromJsonTimestamp(json);
+      expect(result.seconds.equals(Long.fromValue(json.seconds))).toBeTruthy();
+      expect(result.nanos).toBe(Number(json.nanos));
+    });
+
+    it("should handle JSON object with missing values", () => {
+      const json = {};
+      const result = fromJsonTimestamp(json);
+      expect(result.seconds.equals(Long.ZERO)).toBeTruthy();
+      expect(result.nanos).toBe(0);
+    });
+  });
+});

package/src/helpers/__test__/internalTimestamp.ts

@@ -0,0 +1,58 @@
+import Long from 'long';
+
+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: Long;
+  /**
+   * 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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+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 = t.seconds.toNumber() * 1000;
+  millis += t.nanos / 1000000;
+  return new Date(millis);
+};
+
+const timestampFromJSON = (object: any): Timestamp => {
+  return {
+    seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO,
+    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 Long.fromNumber(number);
+}

package/src/helpers/__test__/internalTimestampBigint.test.ts

@@ -0,0 +1,78 @@
+import {
+  toTimestamp,
+  fromTimestamp,
+  fromJsonTimestamp,
+} from "./internalTimestampBigint";
+
+describe("Timestamp Utilities", () => {
+  describe("toTimestamp", () => {
+    it("should convert a date to a Timestamp", () => {
+      const date = new Date("2000-01-01T00:00:00Z");
+      const result = toTimestamp(date);
+      expect(result.seconds).toBe(BigInt(946684800)); // 2000-01-01T00:00:00Z in Unix time
+      expect(result.nanos).toBe(0);
+    });
+
+    it("should handle nanosecond conversion correctly", () => {
+      const date = new Date(946684800001); // 1 millisecond after 2000-01-01T00:00:00Z
+      const result = toTimestamp(date);
+      expect(result.seconds).toBe(BigInt(946684800));
+      expect(result.nanos).toBe(1000000); // 1 millisecond is 1,000,000 nanoseconds
+    });
+  });
+
+  describe("fromTimestamp", () => {
+    it("should convert a Timestamp to a date", () => {
+      const timestamp = { seconds: BigInt(946684800), nanos: 0 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(946684800000); // 2000-01-01T00:00:00Z in Unix time
+    });
+
+    it("should handle nanosecond conversion correctly", () => {
+      const timestamp = { seconds: BigInt(946684800), nanos: 1000000 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(946684800001); // 1 millisecond after 2000-01-01T00:00:00Z
+    });
+
+    it("should handle negative seconds with positive nanoseconds", () => {
+      const timestamp = { seconds: BigInt(-1), nanos: 1000000 };
+      const result = fromTimestamp(timestamp);
+      expect(result.getTime()).toBe(-999); // 1 millisecond before 1970-01-01T00:00:00Z
+    });
+  });
+
+  describe("fromJsonTimestamp", () => {
+    it("should convert a Date object to a Timestamp", () => {
+      const date = new Date("2000-01-01T00:00:00Z");
+      const result = fromJsonTimestamp(date);
+      const expected = toTimestamp(date);
+      expect(result.seconds).toBe(expected.seconds);
+      expect(result.nanos).toBe(expected.nanos);
+    });
+
+    it("should convert a string date to a Timestamp", () => {
+      const dateString = "2000-01-01T00:00:00Z";
+      const result = fromJsonTimestamp(dateString);
+      const expected = toTimestamp(new Date(dateString));
+      expect(result.seconds).toBe(expected.seconds);
+      expect(result.nanos).toBe(expected.nanos);
+    });
+
+    it("should convert a JSON object with string values to a Timestamp", () => {
+      const json = {
+        seconds: "946684800",
+        nanos: "1000000",
+      };
+      const result = fromJsonTimestamp(json);
+      expect(result.seconds).toBe(BigInt(json.seconds));
+      expect(result.nanos).toBe(Number(json.nanos));
+    });
+
+    it("should handle JSON object with missing values", () => {
+      const json = {};
+      const result = fromJsonTimestamp(json);
+      expect(result.seconds).toBe(BigInt(0));
+      expect(result.nanos).toBe(0);
+    });
+  });
+});

package/src/helpers/__test__/internalTimestampBigint.ts

@@ -0,0 +1,58 @@
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+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));
+}