@hyperweb/telescope 1.15.0

package/main/helpers/registry-helper.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistryHelper = void 0;
+const getRegistryHelper = (options) => {
+    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);
+`;
+};
+exports.getRegistryHelper = getRegistryHelper;

package/main/helpers/types-helper.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypesHelper = void 0;
+const getTypesHelper = (options) => {
+    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 { 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;
+}
+`}
+`;
+};
+exports.getTypesHelper = getTypesHelper;

package/main/helpers/utf8-helper.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8 = void 0;
+exports.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;
+}
+`;