@hyperweb/telescope 2.1.0 → 2.2.0

package/src/helpers/decimals.ts

@@ -1,108 +0,0 @@
-export const decimal = `
-// The largest value we need is 18 (Ether).
-const maxFractionalDigits = 30;
-/**
- * A type for arbitrary precision, non-negative decimals.
- *
- * Instances of this class are immutable.
- */
-export class Decimal {
-  public static fromUserInput(
-    input: string,
-    fractionalDigits: number
-  ): Decimal {
-    Decimal.verifyFractionalDigits(fractionalDigits);
-    const badCharacter = input.match(/[^0-9.]/);
-    if (badCharacter) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      throw new Error(
-        \`Invalid character at position \${badCharacter.index! + 1}\`
-      );
-    }
-    let whole: string;
-    let fractional: string;
-    if (input === "") {
-      whole = "0";
-      fractional = "";
-    } else if (input.search(/\\./) === -1) {
-      // integer format, no separator
-      whole = input;
-      fractional = "";
-    } else {
-      const parts = input.split(".");
-      switch (parts.length) {
-        case 0:
-        case 1:
-          throw new Error(
-            "Fewer than two elements in split result. This must not happen here."
-          );
-        case 2:
-          if (!parts[1]) throw new Error("Fractional part missing");
-          whole = parts[0];
-          fractional = parts[1].replace(/0+$/, "");
-          break;
-        default:
-          throw new Error("More than one separator found");
-      }
-    }
-    if (fractional.length > fractionalDigits) {
-      throw new Error("Got more fractional digits than supported");
-    }
-    const quantity = \`\${whole}\${fractional.padEnd(fractionalDigits, "0")}\`;
-    return new Decimal(quantity, fractionalDigits);
-  }
-  public static fromAtomics(
-    atomics: string,
-    fractionalDigits: number
-  ): Decimal {
-    Decimal.verifyFractionalDigits(fractionalDigits);
-    return new Decimal(atomics, fractionalDigits);
-  }
-  private static verifyFractionalDigits(fractionalDigits: number): void {
-    if (!Number.isInteger(fractionalDigits))
-      throw new Error("Fractional digits is not an integer");
-    if (fractionalDigits < 0)
-      throw new Error("Fractional digits must not be negative");
-    if (fractionalDigits > maxFractionalDigits) {
-      throw new Error(
-        \`Fractional digits must not exceed \${maxFractionalDigits}\`
-      );
-    }
-  }
-  public get atomics(): string {
-    return this.data.atomics.toString();
-  }
-  public get fractionalDigits(): number {
-    return this.data.fractionalDigits;
-  }
-  private readonly data: {
-    readonly atomics: bigint;
-    readonly fractionalDigits: number;
-  };
-  private constructor(atomics: string, fractionalDigits: number) {
-    if (!atomics.match(/^[0-9]+$/)) {
-      throw new Error(
-        "Invalid string format. Only non-negative integers in decimal representation supported."
-      );
-    }
-    this.data = {
-      atomics: BigInt(atomics),
-      fractionalDigits: fractionalDigits,
-    };
-  }
-  public toString(): string {
-    const factor = BigInt(10) ** BigInt(this.data.fractionalDigits);
-    const whole = this.data.atomics / factor;
-    const fractional = this.data.atomics % factor;
-    if (fractional === 0n) {
-      return whole.toString();
-    } else {
-      const fullFractionalPart = fractional
-        .toString()
-        .padStart(this.data.fractionalDigits, "0");
-      const trimmedFractionalPart = fullFractionalPart.replace(/0+$/, "");
-      return \`\${whole.toString()}.\${trimmedFractionalPart}\`;
-    }
-  }
-}
-`;

package/src/helpers/external-comet.ts

@@ -1,49 +0,0 @@
-export const externalComet = `import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate'
-import { connectComet, Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc";
-
-const _rpcClients: Record<string, ProtobufRpcClient> = {};
-
-export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => {
-    if (typeof rpcEndpoint === 'string') {
-        return rpcEndpoint;
-    } else if (!!rpcEndpoint) {
-        //@ts-ignore
-        return rpcEndpoint.url;
-    }
-}
-
-export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => {
-    const key = getRpcEndpointKey(rpcEndpoint);
-    if (!key) return;
-    if (_rpcClients.hasOwnProperty(key)) {
-        return _rpcClients[key];
-    }
-    const cometClient = await connectComet(rpcEndpoint);
-    //@ts-ignore
-    const client = new QueryClient(cometClient);
-    const rpc = createProtobufRpcClient(client);
-    _rpcClients[key] = rpc;
-    return rpc;
-}
-
-export const createRpcClient = async (rpcEndpoint: string | HttpEndpoint) => {
-  const cometClient = await connectComet(rpcEndpoint);
-  //@ts-ignore
-  const client = new QueryClient(cometClient);
-  const rpc = createProtobufRpcClient(client);
-
-  return rpc;
-}
-
-export const createTm34QueryClient = async (rpcEndpoint: string | HttpEndpoint) => {
-    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
-    //@ts-ignore
-    return new QueryClient(tmClient);
-}
-
-export const createConnectCometQueryClient = async (rpcEndpoint: string | HttpEndpoint) => {
-    const cometClient = await connectComet(rpcEndpoint);
-    //@ts-ignore
-    return new QueryClient(cometClient);
-}
-`;

package/src/helpers/external-icjs.ts

@@ -1,43 +0,0 @@
-export const externalIcJs = `
-import { HttpEndpoint } from "@interchainjs/types";
-import { Rpc } from "./helpers";
-import { ClientOptions, createCosmosQueryClient } from "@interchainjs/cosmos";
-
-const _rpcClients: Record<string, Rpc> = {};
-
-export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => {
-  if (typeof rpcEndpoint === 'string') {
-    return rpcEndpoint;
-  } else if (!!rpcEndpoint) {
-    //@ts-ignore
-    return rpcEndpoint.url;
-  }
-}
-
-export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => {
-  const key = getRpcEndpointKey(rpcEndpoint);
-  if (!key) return;
-  if (_rpcClients.hasOwnProperty(key)) {
-    return _rpcClients[key];
-  }
-  const rpc = await createRpcClient(rpcEndpoint);
-  _rpcClients[key] = rpc;
-  return rpc;
-}
-
-export const createRpcClient = async (rpcEndpoint: string | HttpEndpoint,
-  options?: ClientOptions
-) => {
-  if (typeof rpcEndpoint === 'string') {
-    return createCosmosQueryClient(rpcEndpoint, options);
-  } else {
-    const endpointStr = rpcEndpoint.url;
-    const clientOptions = {
-      ...options,
-      headers: rpcEndpoint.headers
-    };
-
-    return createCosmosQueryClient(endpointStr, clientOptions);
-  }
-}
-`;

package/src/helpers/external.ts

@@ -1,28 +0,0 @@
-export const external = `import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate'
-import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc";
-
-const _rpcClients: Record<string, ProtobufRpcClient> = {};
-
-export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => {
-    if (typeof rpcEndpoint === 'string') {
-        return rpcEndpoint;
-    } else if (!!rpcEndpoint) {
-        //@ts-ignore
-        return rpcEndpoint.url;
-    }
-}
-
-export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => {
-    const key = getRpcEndpointKey(rpcEndpoint);
-    if (!key) return;
-    if (_rpcClients.hasOwnProperty(key)) {
-        return _rpcClients[key];
-    }
-    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
-    //@ts-ignore
-    const client = new QueryClient(tmClient);
-    const rpc = createProtobufRpcClient(client);
-    _rpcClients[key] = rpc;
-    return rpc;
-}
-`;

package/src/helpers/grpc-gateway.ts

@@ -1,345 +0,0 @@
-export const grpcGateway = `
-
-/**
- * base64 encoder and decoder
- * Copied and adapted from https://github.com/protobufjs/protobuf.js/blob/master/lib/base64/index.js
- */
-// Base64 encoding table
-const b64 = new Array(64);
-
-// Base64 decoding table
-const s64 = new Array(123);
-
-// 65..90, 97..122, 48..57, 43, 47
-for (let i = 0; i < 64;)
-    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-export function b64Encode(buffer: Uint8Array, start: number, end: number): string {
-	let parts: string[] = null;
-  const chunk = [];
-  let i = 0, // output index
-    j = 0, // goto index
-    t;     // temporary
-  while (start < end) {
-    const b = buffer[start++];
-    switch (j) {
-      case 0:
-        chunk[i++] = b64[b >> 2];
-        t = (b & 3) << 4;
-        j = 1;
-        break;
-      case 1:
-        chunk[i++] = b64[t | b >> 4];
-        t = (b & 15) << 2;
-        j = 2;
-        break;
-      case 2:
-        chunk[i++] = b64[t | b >> 6];
-        chunk[i++] = b64[b & 63];
-        j = 0;
-        break;
-    }
-    if (i > 8191) {
-      (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-      i = 0;
-    }
-  }
-  if (j) {
-    chunk[i++] = b64[t];
-    chunk[i++] = 61;
-    if (j === 1)
-      chunk[i++] = 61;
-  }
-  if (parts) {
-    if (i)
-      parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-    return parts.join("");
-  }
-  return String.fromCharCode.apply(String, chunk.slice(0, i));
-}
-
-const invalidEncoding = "invalid encoding";
-
-export function b64Decode(s: string): Uint8Array {
-	const buffer = [];
-	let offset = 0;
-  let j = 0, // goto index
-      t;     // temporary
-  for (let i = 0; i < s.length;) {
-    let c = s.charCodeAt(i++);
-    if (c === 61 && j > 1)
-        break;
-    if ((c = s64[c]) === undefined)
-        throw Error(invalidEncoding);
-    switch (j) {
-      case 0:
-        t = c;
-        j = 1;
-        break;
-      case 1:
-        buffer[offset++] = t << 2 | (c & 48) >> 4;
-        t = c;
-        j = 2;
-        break;
-      case 2:
-        buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-        t = c;
-        j = 3;
-        break;
-      case 3:
-        buffer[offset++] = (t & 3) << 6 | c;
-        j = 0;
-        break;
-    }
-  }
-  if (j === 1)
-      throw Error(invalidEncoding);
-  return new Uint8Array(buffer);
-}
-
-function b64Test(s: string): boolean {
-	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(s);
-}
-
-export interface InitReq extends RequestInit {
-  pathPrefix?: string
-}
-
-export function replacer(key: any, value: any): any {
-  if(value && value.constructor === Uint8Array) {
-    return b64Encode(value, 0, value.length);
-  }
-
-  return value;
-}
-
-export function fetchReq<I, O>(path: string, init?: InitReq): Promise<O> {
-  const {pathPrefix, ...req} = init || {}
-
-  const url = pathPrefix ? \`\${pathPrefix}\${path}\` : path
-
-  return fetch(url, req).then(r => r.json().then((body: O) => {
-    if (!r.ok) { throw body; }
-    return body;
-  })) as Promise<O>
-}
-
-// NotifyStreamEntityArrival is a callback that will be called on streaming entity arrival
-export type NotifyStreamEntityArrival<T> = (resp: T) => void
-
-/**
- * fetchStreamingRequest is able to handle grpc-gateway server side streaming call
- * it takes NotifyStreamEntityArrival that lets users respond to entity arrival during the call
- * all entities will be returned as an array after the call finishes.
- **/
-export async function fetchStreamingRequest<S, R>(path: string, callback?: NotifyStreamEntityArrival<R>, init?: InitReq) {
-  const {pathPrefix, ...req} = init || {}
-  const url = pathPrefix ? \`\${pathPrefix}\${path}\` : path
-  const result = await fetch(url, req)
-  // needs to use the .ok to check the status of HTTP status code
-  // http other than 200 will not throw an error, instead the .ok will become false.
-  // see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#
-  if (!result.ok) {
-    const resp = await result.json()
-    const errMsg = resp.error && resp.error.message ? resp.error.message : ""
-    throw new Error(errMsg)
-  }
-
-  if (!result.body) {
-    throw new Error("response doesnt have a body")
-  }
-
-  await result.body
-    .pipeThrough(new TextDecoderStream())
-    .pipeThrough<R>(getNewLineDelimitedJSONDecodingStream<R>())
-    .pipeTo(getNotifyEntityArrivalSink((e: R) => {
-      if (callback) {
-        callback(e)
-      }
-    }))
-
-  // wait for the streaming to finish and return the success respond
-  return
-}
-
-/**
- * JSONStringStreamController represents the transform controller that's able to transform the incoming
- * new line delimited json content stream into entities and able to push the entity to the down stream
- */
-interface JSONStringStreamController<T> extends TransformStreamDefaultController {
-  buf?: string
-  pos?: number
-  enqueue: (s: T) => void
-}
-
-/**
- * getNewLineDelimitedJSONDecodingStream returns a TransformStream that's able to handle new line delimited json stream content into parsed entities
- */
-function getNewLineDelimitedJSONDecodingStream<T>(): TransformStream<string, T> {
-  return new TransformStream({
-    start(controller: JSONStringStreamController<T>) {
-      controller.buf = ''
-      controller.pos = 0
-    },
-
-    transform(chunk: string, controller: JSONStringStreamController<T>) {
-      if (controller.buf === undefined) {
-        controller.buf = ''
-      }
-      if (controller.pos === undefined) {
-        controller.pos = 0
-      }
-      controller.buf += chunk
-      while (controller.pos < controller.buf.length) {
-        if (controller.buf[controller.pos] === '\\n') {
-          const line = controller.buf.substring(0, controller.pos)
-          const response = JSON.parse(line)
-          controller.enqueue(response.result)
-          controller.buf = controller.buf.substring(controller.pos + 1)
-          controller.pos = 0
-        } else {
-          ++controller.pos
-        }
-      }
-    }
-  })
-
-}
-
-/**
- * getNotifyEntityArrivalSink takes the NotifyStreamEntityArrival callback and return
- * a sink that will call the callback on entity arrival
- * @param notifyCallback
- */
-function getNotifyEntityArrivalSink<T>(notifyCallback: NotifyStreamEntityArrival<T>) {
-  return new WritableStream<T>({
-    write(entity: T) {
-      notifyCallback(entity)
-    }
-  })
-}
-
-type Primitive = string | boolean | number;
-type RequestPayload = Record<string, unknown>;
-type FlattenedRequestPayload = Record<string, Primitive | Array<Primitive>>;
-
-/**
- * Checks if given value is a plain object
- * Logic copied and adapted from below source: 
- * https://github.com/char0n/ramda-adjunct/blob/master/src/isPlainObj.js
- * @param  {unknown} value
- * @return {boolean}
- */
-function isPlainObject(value: unknown): boolean {
-  const isObject =
-    Object.prototype.toString.call(value).slice(8, -1) === "Object";
-  const isObjLike = value !== null && isObject;
-
-  if (!isObjLike || !isObject) {
-    return false;
-  }
-
-  const proto = Object.getPrototypeOf(value);
-
-  const hasObjectConstructor =
-    typeof proto === "object" &&
-    proto.constructor === Object.prototype.constructor;
-
-  return hasObjectConstructor;
-}
-
-/**
- * Checks if given value is of a primitive type
- * @param  {unknown} value
- * @return {boolean}
- */
-function isPrimitive(value: unknown): boolean {
-  return ["string", "number", "boolean"].some(t => typeof value === t);
-}
-
-/**
- * Checks if given primitive is zero-value
- * @param  {Primitive} value
- * @return {boolean}
- */
-function isZeroValuePrimitive(value: Primitive): boolean {
-  return value === false || value === 0 || value === "";
-}
-
-/**
- * Flattens a deeply nested request payload and returns an object
- * with only primitive values and non-empty array of primitive values
- * as per https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
- * @param  {RequestPayload} requestPayload
- * @param  {String} path
- * @return {FlattenedRequestPayload>}
- */
-function flattenRequestPayload<T extends RequestPayload>(
-  requestPayload: T,
-  path: string = ""
-): FlattenedRequestPayload {
-  return Object.keys(requestPayload).reduce(
-    (acc: T, key: string): T => {
-      const value = requestPayload[key];
-      const newPath = path ? [path, key].join(".") : key;
-
-      const isNonEmptyPrimitiveArray =
-        Array.isArray(value) &&
-        value.every(v => isPrimitive(v)) &&
-        value.length > 0;
-
-      const isNonZeroValuePrimitive =
-        isPrimitive(value) && !isZeroValuePrimitive(value as Primitive);
-
-      let objectToMerge = {};
-
-      if (isPlainObject(value)) {
-        objectToMerge = flattenRequestPayload(value as RequestPayload, newPath);
-      } else if (value && value.constructor === Uint8Array) {
-        objectToMerge = {
-          [newPath]: b64Encode(value, 0, value.length),
-        };
-      } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
-        objectToMerge = { [newPath]: value };
-      }
-
-      return { ...acc, ...objectToMerge };
-    },
-    {} as T
-  ) as FlattenedRequestPayload;
-}
-
-/**
- * Renders a deeply nested request payload into a string of URL search
- * parameters by first flattening the request payload and then removing keys
- * which are already present in the URL path.
- * @param  {RequestPayload} requestPayload
- * @param  {string[]} urlPathParams
- * @return {string}
- */
-export function renderURLSearchParams<T extends RequestPayload>(
-  requestPayload: T,
-  urlPathParams: string[] = []
-): string {
-  const flattenedRequestPayload = flattenRequestPayload(requestPayload);
-
-  const urlSearchParams = Object.keys(flattenedRequestPayload).reduce(
-    (acc: string[][], key: string): string[][] => {
-      // key should not be present in the url path as a parameter
-      const value = flattenedRequestPayload[key];
-      if (urlPathParams.find(f => f === key)) {
-        return acc;
-      }
-      return Array.isArray(value)
-        ? [...acc, ...value.map(m => [key, m.toString()])]
-        : (acc = [...acc, [key, value.toString()]]);
-    },
-    [] as string[][]
-  );
-
-  // react-native's URLSearchParams doesn't like working with array of arrays
-  return urlSearchParams
-    .map((x) => new URLSearchParams({ [x[0]]: x[1] }).toString())
-    .join("&");
-}
-`

package/src/helpers/grpc-web.ts

@@ -1,11 +0,0 @@
-export const grpcWeb = `import { grpc } from "@improbable-eng/grpc-web";
-
-export interface UnaryMethodDefinitionishR
-  extends grpc.UnaryMethodDefinition<any, any> {
-  requestStream: any;
-  responseStream: any;
-}
-
-export type UnaryMethodDefinitionish = UnaryMethodDefinitionishR;
-
-`

package/src/helpers/helper-func-types-interface.ts

@@ -1,104 +0,0 @@
-import { TelescopeOptions } from "@cosmology/types";
-
-export const getHelperFuncTypesForInterface = (options: TelescopeOptions) => {
-  return `
-import { HttpEndpoint } from "@interchainjs/types";
-import { BinaryReader, BinaryWriter } from "./binary${options.restoreImportExtension ?? ""}";${!options.isGeneratingCosmosTypes ? `
-import { getRpcClient } from "./extern${options.restoreImportExtension ?? ""}";` : ''}
-import { isRpc, Rpc } from "./helpers${options.restoreImportExtension ?? ""}";${!options.isGeneratingCosmosTypes ? `
-import { TelescopeGeneratedCodec, DeliverTxResponse, Message, StdFee } from "./types${options.restoreImportExtension ?? ""}";` : ''}${!options.isGeneratingCosmosTypes ? `
-import { toConverters, toEncoders } from "@interchainjs/cosmos";
-import { ISigningClient } from "@interchainjs/cosmos";` : ''}
-
-export interface QueryBuilderOptions<TReq, TRes> {
-  encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter
-  decode: (input: BinaryReader | Uint8Array, length?: number) => TRes
-  service: string,
-  method: string,
-  deps?: TelescopeGeneratedCodec<any, any, any>[],
-}
-
-export function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>) {
-    registerDependencies(opts.deps ?? []);
-
-    return async (client: EndpointOrRpc, request: TReq) => {
-      let rpc: Rpc | undefined;
-
-      if(isRpc(client)) {
-        rpc = client;
-      } else {
-        rpc = ${options.isGeneratingCosmosTypes ? 'undefined' : 'client ? await getRpcClient(client) : undefined'};
-      }
-
-      if (!rpc) throw new Error("Query Rpc is not initialized");
-
-      const data = opts.encode(request).finish();
-      const response = await rpc.request(opts.service, opts.method, data);
-      return opts.decode(response);
-    };
-}
-
-${!options.isGeneratingCosmosTypes ? `export interface ITxArgs<TMsg> {
-  signerAddress: string;
-  message: TMsg | TMsg[];
-  fee: StdFee | 'auto';
-  memo: string;
-}
-
-export interface TxBuilderOptions {
-  msg: TelescopeGeneratedCodec<any, any, any>
-}
-
-export function buildTx<TMsg>(opts: TxBuilderOptions) {
-  if(opts.msg){
-    registerDependencies([opts.msg]);
-  }
-
-  return async (
-    client: ISigningClient,
-    signerAddress: string,
-    message: TMsg | TMsg[],
-    fee: StdFee | 'auto',
-    memo: string
-  ): Promise<DeliverTxResponse> => {
-    if (!client) throw new Error("SigningClient is not initialized");
-
-    //register all related encoders and converters
-    client.addEncoders?.(toEncoders(opts.msg));
-    client.addConverters?.(toConverters(opts.msg));
-
-    const data = Array.isArray(message)
-      ? message.map(msg => ({
-          typeUrl: opts.msg.typeUrl,
-          value: msg,
-        }))
-      : [{
-          typeUrl: opts.msg.typeUrl,
-          value: message,
-        }];
-    return client.signAndBroadcast!(signerAddress, data, fee, memo);
-  };
-}` : ''}
-
-export interface Encoder {
-  typeUrl: string;
-  fromPartial: (data: any) => any;
-  encode: (data: any) => Uint8Array;
-}
-
-export interface AminoConverter {
-  typeUrl: string;
-  aminoType: string;
-  fromAmino: (data: any) => any;
-  toAmino: (data: any) => any;
-}
-
-export type EndpointOrRpc = string | HttpEndpoint | Rpc ;
-
-function registerDependencies(deps: TelescopeGeneratedCodec<any, any, any>[]) {
-  for (const dep of deps) {
-    dep.registerTypeUrl?.();
-  }
-}
-`;
-};