atlas.js-protos 0.1.0

package/dist/types/cosmos/base/v1beta1/coin.mjs

@@ -0,0 +1,284 @@
+//@ts-nocheck
+import * as _m0 from "protobufjs/minimal";
+import { GlobalDecoderRegistry } from "../../../registry";
+import { Decimal } from "@interchainjs/math";
+function createBaseCoin() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+/**
+ * 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.
+ * @name Coin
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.Coin
+ */
+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");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    encode(message, writer = _m0.Writer.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 _m0.Reader ? input : new _m0.Reader(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;
+    },
+    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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(Coin.typeUrl, Coin);
+GlobalDecoderRegistry.registerAminoProtoMapping(Coin.aminoType, Coin.typeUrl);
+function createBaseDecCoin() {
+    return {
+        denom: "",
+        amount: ""
+    };
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ *
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ * @name DecCoin
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.DecCoin
+ */
+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");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(Decimal.fromUserInput(message.amount, 18).atomics);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecCoin();
+        message.denom = object.denom ?? "";
+        message.amount = object.amount ?? "";
+        return 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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(DecCoin.typeUrl, DecCoin);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecCoin.aminoType, DecCoin.typeUrl);
+function createBaseIntProto() {
+    return {
+        int: ""
+    };
+}
+/**
+ * IntProto defines a Protobuf wrapper around an Int object.
+ * Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
+ * @name IntProto
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.IntProto
+ */
+export const IntProto = {
+    typeUrl: "/cosmos.base.v1beta1.IntProto",
+    aminoType: "cosmos-sdk/IntProto",
+    is(o) {
+        return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.int !== "") {
+            writer.uint32(10).string(message.int);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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;
+    },
+    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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(IntProto.typeUrl, IntProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(IntProto.aminoType, IntProto.typeUrl);
+function createBaseDecProto() {
+    return {
+        dec: ""
+    };
+}
+/**
+ * DecProto defines a Protobuf wrapper around a Dec object.
+ * Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
+ * @name DecProto
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.DecProto
+ */
+export const DecProto = {
+    typeUrl: "/cosmos.base.v1beta1.DecProto",
+    aminoType: "cosmos-sdk/DecProto",
+    is(o) {
+        return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.dec !== "") {
+            writer.uint32(10).string(Decimal.fromUserInput(message.dec, 18).atomics);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecProto();
+        message.dec = object.dec ?? "";
+        return 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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(DecProto.typeUrl, DecProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecProto.aminoType, DecProto.typeUrl);