injectivejs 1.4.0 → 1.6.0

package/esm/cosmos/base/query/v1beta1/pagination.js

@@ -0,0 +1,219 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBasePageRequest() {
+    return {
+        key: new Uint8Array(),
+        offset: BigInt(0),
+        limit: BigInt(0),
+        countTotal: false,
+        reverse: false
+    };
+}
+export const PageRequest = {
+    typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+    aminoType: "cosmos-sdk/PageRequest",
+    is(o) {
+        return o && (o.$typeUrl === PageRequest.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && typeof o.offset === "bigint" && typeof o.limit === "bigint" && typeof o.countTotal === "boolean" && typeof o.reverse === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PageRequest.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && typeof o.offset === "bigint" && typeof o.limit === "bigint" && typeof o.count_total === "boolean" && typeof o.reverse === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        if (message.offset !== BigInt(0)) {
+            writer.uint32(16).uint64(message.offset);
+        }
+        if (message.limit !== BigInt(0)) {
+            writer.uint32(24).uint64(message.limit);
+        }
+        if (message.countTotal === true) {
+            writer.uint32(32).bool(message.countTotal);
+        }
+        if (message.reverse === true) {
+            writer.uint32(40).bool(message.reverse);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePageRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                case 2:
+                    message.offset = reader.uint64();
+                    break;
+                case 3:
+                    message.limit = reader.uint64();
+                    break;
+                case 4:
+                    message.countTotal = reader.bool();
+                    break;
+                case 5:
+                    message.reverse = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePageRequest();
+        message.key = object.key ?? new Uint8Array();
+        message.offset = object.offset !== undefined && object.offset !== null ? BigInt(object.offset.toString()) : BigInt(0);
+        message.limit = object.limit !== undefined && object.limit !== null ? BigInt(object.limit.toString()) : BigInt(0);
+        message.countTotal = object.countTotal ?? false;
+        message.reverse = object.reverse ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePageRequest();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = bytesFromBase64(object.key);
+        }
+        if (object.offset !== undefined && object.offset !== null) {
+            message.offset = BigInt(object.offset);
+        }
+        if (object.limit !== undefined && object.limit !== null) {
+            message.limit = BigInt(object.limit);
+        }
+        if (object.count_total !== undefined && object.count_total !== null) {
+            message.countTotal = object.count_total;
+        }
+        if (object.reverse !== undefined && object.reverse !== null) {
+            message.reverse = object.reverse;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? base64FromBytes(message.key) : undefined;
+        obj.offset = message.offset !== BigInt(0) ? message.offset?.toString() : undefined;
+        obj.limit = message.limit !== BigInt(0) ? message.limit?.toString() : undefined;
+        obj.count_total = message.countTotal === false ? undefined : message.countTotal;
+        obj.reverse = message.reverse === false ? undefined : message.reverse;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PageRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PageRequest",
+            value: PageRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PageRequest.decode(message.value);
+    },
+    toProto(message) {
+        return PageRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+            value: PageRequest.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(PageRequest.typeUrl, PageRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(PageRequest.aminoType, PageRequest.typeUrl);
+function createBasePageResponse() {
+    return {
+        nextKey: new Uint8Array(),
+        total: BigInt(0)
+    };
+}
+export const PageResponse = {
+    typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+    aminoType: "cosmos-sdk/PageResponse",
+    is(o) {
+        return o && (o.$typeUrl === PageResponse.typeUrl || (o.nextKey instanceof Uint8Array || typeof o.nextKey === "string") && typeof o.total === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PageResponse.typeUrl || (o.next_key instanceof Uint8Array || typeof o.next_key === "string") && typeof o.total === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.nextKey.length !== 0) {
+            writer.uint32(10).bytes(message.nextKey);
+        }
+        if (message.total !== BigInt(0)) {
+            writer.uint32(16).uint64(message.total);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nextKey = reader.bytes();
+                    break;
+                case 2:
+                    message.total = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePageResponse();
+        message.nextKey = object.nextKey ?? new Uint8Array();
+        message.total = object.total !== undefined && object.total !== null ? BigInt(object.total.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePageResponse();
+        if (object.next_key !== undefined && object.next_key !== null) {
+            message.nextKey = bytesFromBase64(object.next_key);
+        }
+        if (object.total !== undefined && object.total !== null) {
+            message.total = BigInt(object.total);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.next_key = message.nextKey ? base64FromBytes(message.nextKey) : undefined;
+        obj.total = message.total !== BigInt(0) ? message.total?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PageResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PageResponse",
+            value: PageResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PageResponse.decode(message.value);
+    },
+    toProto(message) {
+        return PageResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+            value: PageResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(PageResponse.typeUrl, PageResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(PageResponse.aminoType, PageResponse.typeUrl);

package/esm/cosmos/base/v1beta1/coin.js

@@ -0,0 +1,338 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseCoin() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+export const Coin = {
+    typeUrl: "/cosmos.base.v1beta1.Coin",
+    aminoType: "cosmos-sdk/Coin",
+    is(o) {
+        return o && (o.$typeUrl === Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCoin();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCoin();
+        message.denom = object.denom ?? "";
+        message.amount = object.amount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCoin();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.amount = message.amount ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Coin.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Coin",
+            value: Coin.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Coin.decode(message.value);
+    },
+    toProto(message) {
+        return Coin.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.Coin",
+            value: Coin.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Coin.typeUrl, Coin);
+GlobalDecoderRegistry.registerAminoProtoMapping(Coin.aminoType, Coin.typeUrl);
+function createBaseDecCoin() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+export const DecCoin = {
+    typeUrl: "/cosmos.base.v1beta1.DecCoin",
+    aminoType: "cosmos-sdk/DecCoin",
+    is(o) {
+        return o && (o.$typeUrl === DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDecCoin();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecCoin();
+        message.denom = object.denom ?? "";
+        message.amount = object.amount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecCoin();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DecCoin.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/DecCoin",
+            value: DecCoin.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return DecCoin.decode(message.value);
+    },
+    toProto(message) {
+        return DecCoin.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.DecCoin",
+            value: DecCoin.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(DecCoin.typeUrl, DecCoin);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecCoin.aminoType, DecCoin.typeUrl);
+function createBaseIntProto() {
+    return {
+        int: ""
+    };
+}
+export const IntProto = {
+    typeUrl: "/cosmos.base.v1beta1.IntProto",
+    aminoType: "cosmos-sdk/IntProto",
+    is(o) {
+        return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.int !== "") {
+            writer.uint32(10).string(message.int);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIntProto();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.int = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseIntProto();
+        message.int = object.int ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseIntProto();
+        if (object.int !== undefined && object.int !== null) {
+            message.int = object.int;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.int = message.int === "" ? undefined : message.int;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return IntProto.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/IntProto",
+            value: IntProto.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return IntProto.decode(message.value);
+    },
+    toProto(message) {
+        return IntProto.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.IntProto",
+            value: IntProto.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(IntProto.typeUrl, IntProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(IntProto.aminoType, IntProto.typeUrl);
+function createBaseDecProto() {
+    return {
+        dec: ""
+    };
+}
+export const DecProto = {
+    typeUrl: "/cosmos.base.v1beta1.DecProto",
+    aminoType: "cosmos-sdk/DecProto",
+    is(o) {
+        return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.dec !== "") {
+            writer.uint32(10).string(message.dec);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDecProto();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.dec = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecProto();
+        message.dec = object.dec ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecProto();
+        if (object.dec !== undefined && object.dec !== null) {
+            message.dec = object.dec;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.dec = message.dec === "" ? undefined : message.dec;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DecProto.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/DecProto",
+            value: DecProto.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return DecProto.decode(message.value);
+    },
+    toProto(message) {
+        return DecProto.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.DecProto",
+            value: DecProto.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(DecProto.typeUrl, DecProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecProto.aminoType, DecProto.typeUrl);