@hyperweb/telescope 2.1.0 → 2.2.0

package/src/helpers/registry-helper.ts

@@ -1,227 +0,0 @@
-import { TelescopeOptions } from "@cosmology/types";
-
-export const getRegistryHelper = (options: TelescopeOptions) => {
-  return `import { BinaryReader } from "./binary${options.restoreImportExtension ?? ""}";
-import { Any, AnyAmino } from "./google/protobuf/any${options.restoreImportExtension ?? ""}";
-import { IProtoType, TelescopeGeneratedCodec } from "./types${options.restoreImportExtension ?? ""}";
-
-export class GlobalDecoderRegistry {
-  static registry: {
-    [key: string]: TelescopeGeneratedCodec<any, any, any>;
-  } = {};
-
-  static aminoProtoMapping: {
-    [key: string]: string;
-  } = {};
-
-  static existingTypeUrls: string[] = [];
-
-  static registerExistingTypeUrl(typeUrl: string): boolean {
-    if (GlobalDecoderRegistry.existingTypeUrls.includes(typeUrl)) {
-      return false;
-    }
-    GlobalDecoderRegistry.existingTypeUrls.push(typeUrl);
-    return true;
-  }
-
-  static registerAminoProtoMapping(aminoType: string, typeUrl: string) {
-    GlobalDecoderRegistry.aminoProtoMapping[aminoType] = typeUrl;
-  }
-
-  static register<T, SDK, Amino>(
-    key: string,
-    decoder: TelescopeGeneratedCodec<T, SDK, Amino>
-  ) {
-    GlobalDecoderRegistry.registry[key] = decoder;
-  }
-  static getDecoder<T, SDK, Amino>(
-    key: string
-  ): TelescopeGeneratedCodec<T, SDK, Amino> {
-    return GlobalDecoderRegistry.registry[key];
-  }
-  static getDecoderByInstance<T, SDK, Amino>(
-    obj: unknown
-  ): TelescopeGeneratedCodec<T, SDK, Amino> | null {
-    if (obj === undefined || obj === null) {
-      return null;
-    }
-    const protoType = obj as IProtoType;
-
-    if (protoType.$typeUrl) {
-      return GlobalDecoderRegistry.getDecoder<T, SDK, Amino>(
-        protoType.$typeUrl
-      );
-    }
-
-    for (const key in GlobalDecoderRegistry.registry) {
-      if (
-        Object.prototype.hasOwnProperty.call(
-          GlobalDecoderRegistry.registry,
-          key
-        )
-      ) {
-        const element = GlobalDecoderRegistry.registry[key];
-
-        if (element.is!(obj)) {
-          return element;
-        }
-
-        if (element.isSDK && element.isSDK(obj)) {
-          return element;
-        }
-
-        if (element.isAmino && element.isAmino(obj)) {
-          return element;
-        }
-      }
-    }
-
-    return null;
-  }
-  static getDecoderByAminoType<T, SDK, Amino>(
-    type: string
-  ): TelescopeGeneratedCodec<T, SDK, Amino> | null {
-    if (type === undefined || type === null) {
-      return null;
-    }
-
-    const typeUrl = GlobalDecoderRegistry.aminoProtoMapping[type];
-
-    if (!typeUrl) {
-      return null;
-    }
-
-    return GlobalDecoderRegistry.getDecoder<T, SDK, Amino>(typeUrl);
-  }
-  static wrapAny(obj: unknown): Any {
-    if(Any.is(obj)){
-      return obj;
-    }
-
-    const decoder = getDecoderByInstance(obj);
-
-    return {
-      typeUrl: decoder.typeUrl,
-      value: decoder.encode(obj).finish(),
-    };
-  }
-  static unwrapAny<T, SDK, Amino>(input: BinaryReader | Uint8Array | Any) {
-    let data;
-
-    if (Any.is(input)) {
-      data = input;
-    } else {
-      const reader =
-        input instanceof BinaryReader ? input : new BinaryReader(input);
-
-      data = Any.decode(reader, reader.uint32());
-    }
-
-    const decoder = GlobalDecoderRegistry.getDecoder<T, SDK, Amino>(
-      data.typeUrl
-    );
-
-    if (!decoder) {
-      return data;
-    }
-
-    return decoder.decode(data.value);
-  }
-  static fromJSON<T>(object: any): T {
-    const decoder = getDecoderByInstance<T>(object);
-    return decoder.fromJSON!(object);
-  }
-  static toJSON<T>(message: T): any {
-    const decoder = getDecoderByInstance<T>(message);
-    return decoder.toJSON!(message);
-  }
-  static fromPartial<T>(object: unknown): T {
-    const decoder = getDecoderByInstance<T>(object);
-    return decoder ? decoder.fromPartial(object) : (object as T);
-  }
-  static fromSDK<T = unknown, SDK = unknown>(object: SDK): T {
-    const decoder = getDecoderByInstance<T, SDK>(object);
-    return decoder.fromSDK!(object);
-  }
-  static fromSDKJSON<SDK = unknown>(object: any): SDK {
-    const decoder = getDecoderByInstance<unknown, SDK>(object);
-    return decoder.fromSDKJSON!(object);
-  }
-  static toSDK<T = unknown, SDK = unknown>(object: T): SDK {
-    const decoder = getDecoderByInstance<T, SDK>(object);
-    return decoder.toSDK!(object);
-  }
-  static fromAmino<T = unknown, Amino = unknown>(object: Amino): T {
-    const decoder = getDecoderByInstance<T, unknown, Amino>(object);
-    return decoder.fromAmino!(object);
-  }
-  static fromAminoMsg<T = unknown, Amino = unknown>(object: AnyAmino): T {
-    const decoder = GlobalDecoderRegistry.getDecoderByAminoType<
-      T,
-      unknown,
-      Amino
-    >(object.type);
-
-    if (!decoder) {
-      throw new Error(\`There's no decoder for the amino type \${object.type}\`);
-    }
-
-    return decoder.fromAminoMsg!(object);
-  }
-  static toAmino<T = unknown, Amino = unknown>(object: T): Amino {
-    let data: any;
-    let decoder: TelescopeGeneratedCodec<any, any, any>;
-    if (Any.is(object)) {
-      data = GlobalDecoderRegistry.unwrapAny(object);
-
-      decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
-
-      if (!decoder) {
-        decoder = Any;
-      }
-    } else {
-      data = object;
-      decoder = getDecoderByInstance<T, unknown, Amino>(object);
-    }
-
-    return decoder.toAmino!(data);
-  }
-  static toAminoMsg<T = unknown, Amino = unknown>(object: T): AnyAmino {
-    let data: any;
-    let decoder: TelescopeGeneratedCodec<any, any, any>;
-    if (Any.is(object)) {
-      data = GlobalDecoderRegistry.unwrapAny(object);
-
-      decoder = GlobalDecoderRegistry.getDecoder(object.typeUrl);
-
-      if (!decoder) {
-        decoder = Any;
-      }
-    } else {
-      data = object;
-      decoder = getDecoderByInstance<T, unknown, Amino>(object);
-    }
-
-    return decoder.toAminoMsg!(data);
-  }
-}
-
-function getDecoderByInstance<T = unknown, SDK = unknown, Amino = unknown>(
-  obj: unknown
-): TelescopeGeneratedCodec<T, SDK, Amino> {
-  const decoder = GlobalDecoderRegistry.getDecoderByInstance<T, SDK, Amino>(
-    obj
-  );
-
-  if (!decoder) {
-    throw new Error(
-      \`There's no decoder for the instance \${JSON.stringify(obj)}\`
-    );
-  }
-
-  return decoder;
-}
-
-GlobalDecoderRegistry.register(Any.typeUrl, Any);
-`;
-};

package/src/helpers/types-helper.ts

@@ -1,169 +0,0 @@
-import { TelescopeOptions } from "@cosmology/types";
-
-export const getTypesHelper = (options: TelescopeOptions) => {
-  return `import { IBinaryReader, IBinaryWriter } from "./binary${
-    options.restoreImportExtension ?? ""
-  }";
-import { Any } from "./google/protobuf/any${
-    options.restoreImportExtension ?? ""
-  }";
-${options.useInterchainJs ? '' : `import { OfflineSigner } from "@cosmjs/proto-signing";`}
-import { HttpEndpoint } from "${
-    options.useInterchainJs ? "@interchainjs/types" : "@cosmjs/tendermint-rpc"
-  }";
-${options.useInterchainJs ? `
-
-import { DeliverTxResponse, Event, Attribute } from "@interchainjs/types";
-
-export type { DeliverTxResponse }
-
-` : ''}
-export type ProtoMsg = Omit<Any, "typeUrl"> & { typeUrl: any };
-
-export interface IAminoMsg<Amino> {
-  type: any;
-  value: Amino;
-}
-
-export interface IProtoType {
-  $typeUrl?: any;
-}
-
-/**
- * A type generated by Telescope 1.0.
- */
-export interface TelescopeGeneratedCodec<
-  T = unknown,
-  SDK = unknown,
-  Amino = unknown
-> {
-  readonly typeUrl: string;
-  readonly aminoType?: string;
-  is?(o: unknown): o is T;
-  isSDK?(o: unknown): o is SDK;
-  isAmino?(o: unknown): o is Amino;
-  encode: (message: T, writer?: IBinaryWriter | any) => IBinaryWriter | any;
-  decode: (input: IBinaryReader | Uint8Array | any, length?: number) => T;
-  fromPartial: (object: any) => T | any;
-  fromJSON?: (object: any) => T | any;
-  toJSON?: (message: T | any) => any;
-  fromSDK?: (sdk: SDK) => T;
-  fromSDKJSON?: (object: any) => SDK;
-  toSDK?: (message: T) => SDK;
-  fromAmino?: (amino: Amino) => T;
-  toAmino?: (message: T) => Amino;
-  fromAminoMsg?: (aminoMsg: IAminoMsg<Amino>) => T;
-  toAminoMsg?: (message: T) => IAminoMsg<Amino>;
-  toProto?: (message: T) => Uint8Array;
-  fromProtoMsg?: (message: ProtoMsg) => T;
-  toProtoMsg?: (message: T) => Any;
-  registerTypeUrl?: () => void;
-}
-
-export type TelescopeGeneratedType<
-  T = unknown,
-  SDK = unknown,
-  Amino = unknown
-> = TelescopeGeneratedCodec<T, SDK, Amino>;
-
-export type GeneratedType = TelescopeGeneratedCodec;
-
-/**
- * Coin defines a token with a denomination and an amount.
- *
- * NOTE: The amount field is an Int which implements the custom method
- * signatures required by gogoproto.
- */
-interface Coin {
-  denom: string;
-  amount: string;
-}
-
-export type EncodeObject = Message<any>;
-
-export interface Message<T> {
-  typeUrl: string;
-  value: T;
-}
-
-export interface StdFee {
-  amount: Coin[];
-  gas: string;
-  /** The granter address that is used for paying with feegrants */
-  granter?: string;
-  /** The fee payer address. The payer must have signed the transaction. */
-  payer?: string;
-}
-
-${options.useInterchainJs ? '' : `
-export interface MsgData {
-  msgType: string;
-  data: Uint8Array;
-}
-export interface Attribute {
-  key: string;
-  value: string;
-  index?: boolean;
-}
-export interface Event {
-  type: string;
-  attributes: readonly Attribute[];
-}
-
-/**
- * The response after successfully broadcasting a transaction.
- * Success or failure refer to the execution result.
- */
-export interface DeliverTxResponse {
-  height: number;
-  /** The position of the transaction within the block. This is a 0-based index. */
-  txIndex: number;
-  /** Error code. The transaction suceeded if and only if code is 0. */
-  code: number;
-  transactionHash: string;
-  events: readonly Event[];
-  /**
-   * A string-based log document.
-   *
-   * This currently seems to merge attributes of multiple events into one event per type
-   * (https://github.com/tendermint/tendermint/issues/9595). You might want to use the \`events\`
-   * field instead.
-   */
-  rawLog?: string;
-  /** @deprecated Use \`msgResponses\` instead. */
-  data?: readonly MsgData[];
-  /**
-   * The message responses of the [TxMsgData](https://github.com/cosmos/cosmos-sdk/blob/v0.46.3/proto/cosmos/base/abci/v1beta1/abci.proto#L128-L140)
-   * as \`Any\`s.
-   * This field is an empty list for chains running Cosmos SDK < 0.46.
-   */
-  msgResponses: Array<{
-    typeUrl: string;
-    value: Uint8Array;
-  }>;
-  gasUsed: bigint;
-  gasWanted: bigint;
-  origin?: any;
-}
-`}
-export interface TxRpc {
-  request(
-    service: string,
-    method: string,
-    data: Uint8Array
-  ): Promise<Uint8Array>;
-  signAndBroadcast?(
-    signerAddress: string,
-    messages: EncodeObject[],
-    fee: StdFee | "auto" | number,
-    memo: string
-  ): Promise<DeliverTxResponse>;
-}
-${options.useInterchainJs ? '' : `
-export interface SigningClientParams {
-  rpcEndpoint: string | HttpEndpoint;
-  signer: OfflineSigner;
-}
-`}
-`;
-};

package/src/helpers/utf8-helper.ts

@@ -1,143 +0,0 @@
-export const utf8 = `
-// Copyright (c) 2016, Daniel Wirtz  All rights reserved.
-
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-
-// * Redistributions of source code must retain the above copyright
-//   notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright
-//   notice, this list of conditions and the following disclaimer in the
-//   documentation and/or other materials provided with the distribution.
-// * Neither the name of its author, nor the names of its contributors
-//   may be used to endorse or promote products derived from this software
-//   without specific prior written permission.
-
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"use strict";
-
-/**
- * Calculates the UTF8 byte length of a string.
- * @param {string} string String
- * @returns {number} Byte length
- */
-export function utf8Length(str: string) {
-  let len = 0,
-    c = 0;
-  for (let i = 0; i < str.length; ++i) {
-    c = str.charCodeAt(i);
-    if (c < 128) len += 1;
-    else if (c < 2048) len += 2;
-    else if (
-      (c & 0xfc00) === 0xd800 &&
-      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00
-    ) {
-      ++i;
-      len += 4;
-    } else len += 3;
-  }
-  return len;
-}
-
-/**
- * Reads UTF8 bytes as a string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} String read
- */
-export function utf8Read(
-  buffer: ArrayLike<number>,
-  start: number,
-  end: number
-) {
-  const len = end - start;
-  if (len < 1) return "";
-  const chunk = [];
-  let parts: string[] = [],
-    i = 0, // char offset
-    t; // temporary
-  while (start < end) {
-    t = buffer[start++];
-    if (t < 128) chunk[i++] = t;
-    else if (t > 191 && t < 224)
-      chunk[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
-    else if (t > 239 && t < 365) {
-      t =
-        (((t & 7) << 18) |
-          ((buffer[start++] & 63) << 12) |
-          ((buffer[start++] & 63) << 6) |
-          (buffer[start++] & 63)) -
-        0x10000;
-      chunk[i++] = 0xd800 + (t >> 10);
-      chunk[i++] = 0xdc00 + (t & 1023);
-    } else
-      chunk[i++] =
-        ((t & 15) << 12) |
-        ((buffer[start++] & 63) << 6) |
-        (buffer[start++] & 63);
-    if (i > 8191) {
-      (parts || (parts = [])).push(String.fromCharCode(...chunk));
-      i = 0;
-    }
-  }
-  if (parts) {
-    if (i) parts.push(String.fromCharCode(...chunk.slice(0, i)));
-    return parts.join("");
-  }
-  return String.fromCharCode(...chunk.slice(0, i));
-}
-
-/**
- * Writes a string as UTF8 bytes.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Bytes written
- */
-export function utf8Write(
-  str: string,
-  buffer: Uint8Array | Array<number>,
-  offset: number
-) {
-  const start = offset;
-  let c1, // character 1
-    c2; // character 2
-  for (let i = 0; i < str.length; ++i) {
-    c1 = str.charCodeAt(i);
-    if (c1 < 128) {
-      buffer[offset++] = c1;
-    } else if (c1 < 2048) {
-      buffer[offset++] = (c1 >> 6) | 192;
-      buffer[offset++] = (c1 & 63) | 128;
-    } else if (
-      (c1 & 0xfc00) === 0xd800 &&
-      ((c2 = str.charCodeAt(i + 1)) & 0xfc00) === 0xdc00
-    ) {
-      c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
-      ++i;
-      buffer[offset++] = (c1 >> 18) | 240;
-      buffer[offset++] = ((c1 >> 12) & 63) | 128;
-      buffer[offset++] = ((c1 >> 6) & 63) | 128;
-      buffer[offset++] = (c1 & 63) | 128;
-    } else {
-      buffer[offset++] = (c1 >> 12) | 224;
-      buffer[offset++] = ((c1 >> 6) & 63) | 128;
-      buffer[offset++] = (c1 & 63) | 128;
-    }
-  }
-  return offset - start;
-}
-`