injectivejs 1.4.0 → 1.6.0

package/tendermint/version/types.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consensus = exports.App = void 0;
+const binary_1 = require("../../binary");
+const registry_1 = require("../../registry");
+function createBaseApp() {
+    return {
+        protocol: BigInt(0),
+        software: ""
+    };
+}
+exports.App = {
+    typeUrl: "/tendermint.version.App",
+    is(o) {
+        return o && (o.$typeUrl === exports.App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.protocol !== BigInt(0)) {
+            writer.uint32(8).uint64(message.protocol);
+        }
+        if (message.software !== "") {
+            writer.uint32(18).string(message.software);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseApp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.protocol = reader.uint64();
+                    break;
+                case 2:
+                    message.software = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseApp();
+        message.protocol = object.protocol !== undefined && object.protocol !== null ? BigInt(object.protocol.toString()) : BigInt(0);
+        message.software = object.software ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseApp();
+        if (object.protocol !== undefined && object.protocol !== null) {
+            message.protocol = BigInt(object.protocol);
+        }
+        if (object.software !== undefined && object.software !== null) {
+            message.software = object.software;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.protocol = message.protocol !== BigInt(0) ? message.protocol?.toString() : undefined;
+        obj.software = message.software === "" ? undefined : message.software;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.App.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.App.decode(message.value);
+    },
+    toProto(message) {
+        return exports.App.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/tendermint.version.App",
+            value: exports.App.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.App.typeUrl, exports.App);
+function createBaseConsensus() {
+    return {
+        block: BigInt(0),
+        app: BigInt(0)
+    };
+}
+exports.Consensus = {
+    typeUrl: "/tendermint.version.Consensus",
+    is(o) {
+        return o && (o.$typeUrl === exports.Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.block !== BigInt(0)) {
+            writer.uint32(8).uint64(message.block);
+        }
+        if (message.app !== BigInt(0)) {
+            writer.uint32(16).uint64(message.app);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseConsensus();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.block = reader.uint64();
+                    break;
+                case 2:
+                    message.app = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseConsensus();
+        message.block = object.block !== undefined && object.block !== null ? BigInt(object.block.toString()) : BigInt(0);
+        message.app = object.app !== undefined && object.app !== null ? BigInt(object.app.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseConsensus();
+        if (object.block !== undefined && object.block !== null) {
+            message.block = BigInt(object.block);
+        }
+        if (object.app !== undefined && object.app !== null) {
+            message.app = BigInt(object.app);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.block = message.block !== BigInt(0) ? message.block?.toString() : undefined;
+        obj.app = message.app !== BigInt(0) ? message.app?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Consensus.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Consensus.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Consensus.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/tendermint.version.Consensus",
+            value: exports.Consensus.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Consensus.typeUrl, exports.Consensus);

package/types.d.ts

@@ -0,0 +1,124 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import { IBinaryReader, IBinaryWriter } from "./binary";
+import { Any } from "./google/protobuf/any";
+import { OfflineSigner } from "@interchainjs/cosmos/types/wallet";
+import { HttpEndpoint } from "@interchainjs/types";
+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;
+}
+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.
+ */
+export 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;
+}
+export interface MsgData {
+    msgType: string;
+    data: Uint8Array;
+}
+export interface Attribute {
+    key: string;
+    value: string;
+    index: boolean;
+}
+export interface Event {
+    type: string;
+    attributes: 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: 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?: 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;
+}
+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>;
+}
+export interface SigningClientParams {
+    rpcEndpoint: string | HttpEndpoint;
+    signer: OfflineSigner;
+}

package/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });

package/utf8.d.ts

@@ -0,0 +1,27 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+export declare function utf8Length(str: string): number;
+/**
+ * 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 declare function utf8Read(buffer: ArrayLike<number>, start: number, end: number): string;
+/**
+ * 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 declare function utf8Write(str: string, buffer: Uint8Array | Array<number>, offset: number): number;

package/utf8.js

@@ -0,0 +1,141 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+// 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";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8Write = exports.utf8Read = exports.utf8Length = void 0;
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+function utf8Length(str) {
+    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;
+}
+exports.utf8Length = utf8Length;
+/**
+ * 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
+ */
+function utf8Read(buffer, start, end) {
+    const len = end - start;
+    if (len < 1)
+        return "";
+    const chunk = [];
+    let parts = [], 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));
+}
+exports.utf8Read = utf8Read;
+/**
+ * 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
+ */
+function utf8Write(str, buffer, offset) {
+    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;
+}
+exports.utf8Write = utf8Write;

package/varint.d.ts

@@ -0,0 +1,105 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.10.11
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export declare function varint64read(this: ReaderLike): [number, number];
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64ToString(lo: number, hi: number): string;
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read(this: ReaderLike): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+/**
+ * encode zig zag
+ */
+export declare function zzEncode(lo: number, hi: number): number[];
+/**
+ * decode zig zag
+ */
+export declare function zzDecode(lo: number, hi: number): number[];
+/**
+ * unsigned int32 without moving pos.
+ */
+export declare function readUInt32(buf: Uint8Array, pos: number): number;
+/**
+ * signed int32 without moving pos.
+ */
+export declare function readInt32(buf: Uint8Array, pos: number): number;
+/**
+ * writing varint32 to pos
+ */
+export declare function writeVarint32(val: number, buf: Uint8Array | number[], pos: number): void;
+/**
+ * writing varint64 to pos
+ */
+export declare function writeVarint64(val: {
+    lo: number;
+    hi: number;
+}, buf: Uint8Array | number[], pos: number): void;
+export declare function int64Length(lo: number, hi: number): 1 | 2 | 4 | 3 | 6 | 7 | 10 | 8 | 9 | 5;
+export declare function writeFixed32(val: number, buf: Uint8Array | number[], pos: number): void;
+export declare function writeByte(val: number, buf: Uint8Array | number[], pos: number): void;
+export {};