atlas.js-protos 0.1.0

package/dist/types/cosmos/base/query/v1beta1/pagination.mjs

@@ -0,0 +1,183 @@
+//@ts-nocheck
+import * as _m0 from "protobufjs/minimal";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBasePageRequest() {
+    return {
+        key: new Uint8Array(),
+        offset: 0,
+        limit: 0,
+        countTotal: false,
+        reverse: false
+    };
+}
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ *
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ * @name PageRequest
+ * @package cosmos.base.query.v1beta1
+ * @see proto type: cosmos.base.query.v1beta1.PageRequest
+ */
+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");
+    },
+    isSDK(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 = _m0.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        if (message.offset !== 0) {
+            writer.uint32(16).uint64(message.offset);
+        }
+        if (message.limit !== 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 _m0.Reader ? input : new _m0.Reader(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 = Number(reader.uint64().toString());
+                    break;
+                case 3:
+                    message.limit = Number(reader.uint64().toString());
+                    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 ? Number(object.offset.toString()) : 0;
+        message.limit = object.limit !== undefined && object.limit !== null ? Number(object.limit.toString()) : 0;
+        message.countTotal = object.countTotal ?? false;
+        message.reverse = object.reverse ?? false;
+        return 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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(PageRequest.typeUrl, PageRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(PageRequest.aminoType, PageRequest.typeUrl);
+function createBasePageResponse() {
+    return {
+        nextKey: new Uint8Array(),
+        total: 0
+    };
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ *
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ * @name PageResponse
+ * @package cosmos.base.query.v1beta1
+ * @see proto type: cosmos.base.query.v1beta1.PageResponse
+ */
+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");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === PageResponse.typeUrl || (o.next_key instanceof Uint8Array || typeof o.next_key === "string") && typeof o.total === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.nextKey.length !== 0) {
+            writer.uint32(10).bytes(message.nextKey);
+        }
+        if (message.total !== 0) {
+            writer.uint32(16).uint64(message.total);
+        }
+        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 = createBasePageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nextKey = reader.bytes();
+                    break;
+                case 2:
+                    message.total = Number(reader.uint64().toString());
+                    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 ? Number(object.total.toString()) : 0;
+        return 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()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(PageResponse.typeUrl, PageResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(PageResponse.aminoType, PageResponse.typeUrl);

package/dist/types/cosmos/base/v1beta1/coin.d.ts

@@ -0,0 +1,193 @@
+import * as _m0 from "protobufjs/minimal";
+/**
+ * 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 interface Coin {
+    denom: string;
+    amount: string;
+}
+export interface CoinProtoMsg {
+    typeUrl: "/cosmos.base.v1beta1.Coin";
+    value: Uint8Array;
+}
+/**
+ * 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 CoinSDKType
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.Coin
+ */
+export interface CoinSDKType {
+    denom: string;
+    amount: string;
+}
+/**
+ * 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 interface DecCoin {
+    denom: string;
+    amount: string;
+}
+export interface DecCoinProtoMsg {
+    typeUrl: "/cosmos.base.v1beta1.DecCoin";
+    value: Uint8Array;
+}
+/**
+ * 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 DecCoinSDKType
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.DecCoin
+ */
+export interface DecCoinSDKType {
+    denom: string;
+    amount: string;
+}
+/**
+ * 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 interface IntProto {
+    int: string;
+}
+export interface IntProtoProtoMsg {
+    typeUrl: "/cosmos.base.v1beta1.IntProto";
+    value: Uint8Array;
+}
+/**
+ * IntProto defines a Protobuf wrapper around an Int object.
+ * Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
+ * @name IntProtoSDKType
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.IntProto
+ */
+export interface IntProtoSDKType {
+    int: string;
+}
+/**
+ * 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 interface DecProto {
+    dec: string;
+}
+export interface DecProtoProtoMsg {
+    typeUrl: "/cosmos.base.v1beta1.DecProto";
+    value: Uint8Array;
+}
+/**
+ * DecProto defines a Protobuf wrapper around a Dec object.
+ * Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
+ * @name DecProtoSDKType
+ * @package cosmos.base.v1beta1
+ * @see proto type: cosmos.base.v1beta1.DecProto
+ */
+export interface DecProtoSDKType {
+    dec: string;
+}
+/**
+ * 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 declare const Coin: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Coin;
+    isSDK(o: any): o is CoinSDKType;
+    encode(message: Coin, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Coin;
+    fromPartial(object: Partial<Coin>): Coin;
+    fromProtoMsg(message: CoinProtoMsg): Coin;
+    toProto(message: Coin): Uint8Array;
+    toProtoMsg(message: Coin): CoinProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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 declare const DecCoin: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is DecCoin;
+    isSDK(o: any): o is DecCoinSDKType;
+    encode(message: DecCoin, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DecCoin;
+    fromPartial(object: Partial<DecCoin>): DecCoin;
+    fromProtoMsg(message: DecCoinProtoMsg): DecCoin;
+    toProto(message: DecCoin): Uint8Array;
+    toProtoMsg(message: DecCoin): DecCoinProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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 declare const IntProto: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is IntProto;
+    isSDK(o: any): o is IntProtoSDKType;
+    encode(message: IntProto, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): IntProto;
+    fromPartial(object: Partial<IntProto>): IntProto;
+    fromProtoMsg(message: IntProtoProtoMsg): IntProto;
+    toProto(message: IntProto): Uint8Array;
+    toProtoMsg(message: IntProto): IntProtoProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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 declare const DecProto: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is DecProto;
+    isSDK(o: any): o is DecProtoSDKType;
+    encode(message: DecProto, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DecProto;
+    fromPartial(object: Partial<DecProto>): DecProto;
+    fromProtoMsg(message: DecProtoProtoMsg): DecProto;
+    toProto(message: DecProto): Uint8Array;
+    toProtoMsg(message: DecProto): DecProtoProtoMsg;
+    registerTypeUrl(): void;
+};

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

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecProto = exports.IntProto = exports.DecCoin = exports.Coin = void 0;
+//@ts-nocheck
+const _m0 = __importStar(require("protobufjs/minimal"));
+const registry_1 = require("../../../registry");
+const math_1 = require("@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
+ */
+exports.Coin = {
+    typeUrl: "/cosmos.base.v1beta1.Coin",
+    aminoType: "cosmos-sdk/Coin",
+    is(o) {
+        return o && (o.$typeUrl === exports.Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === exports.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 exports.Coin.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Coin.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.Coin",
+            value: exports.Coin.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Coin.typeUrl, exports.Coin);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Coin.aminoType, exports.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
+ */
+exports.DecCoin = {
+    typeUrl: "/cosmos.base.v1beta1.DecCoin",
+    aminoType: "cosmos-sdk/DecCoin",
+    is(o) {
+        return o && (o.$typeUrl === exports.DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === exports.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(math_1.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 = math_1.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 exports.DecCoin.decode(message.value);
+    },
+    toProto(message) {
+        return exports.DecCoin.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.DecCoin",
+            value: exports.DecCoin.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+registry_1.GlobalDecoderRegistry.register(exports.DecCoin.typeUrl, exports.DecCoin);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.DecCoin.aminoType, exports.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
+ */
+exports.IntProto = {
+    typeUrl: "/cosmos.base.v1beta1.IntProto",
+    aminoType: "cosmos-sdk/IntProto",
+    is(o) {
+        return o && (o.$typeUrl === exports.IntProto.typeUrl || typeof o.int === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === exports.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 exports.IntProto.decode(message.value);
+    },
+    toProto(message) {
+        return exports.IntProto.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.IntProto",
+            value: exports.IntProto.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+registry_1.GlobalDecoderRegistry.register(exports.IntProto.typeUrl, exports.IntProto);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.IntProto.aminoType, exports.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
+ */
+exports.DecProto = {
+    typeUrl: "/cosmos.base.v1beta1.DecProto",
+    aminoType: "cosmos-sdk/DecProto",
+    is(o) {
+        return o && (o.$typeUrl === exports.DecProto.typeUrl || typeof o.dec === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === exports.DecProto.typeUrl || typeof o.dec === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.dec !== "") {
+            writer.uint32(10).string(math_1.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 = math_1.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 exports.DecProto.decode(message.value);
+    },
+    toProto(message) {
+        return exports.DecProto.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.base.v1beta1.DecProto",
+            value: exports.DecProto.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+registry_1.GlobalDecoderRegistry.register(exports.DecProto.typeUrl, exports.DecProto);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.DecProto.aminoType, exports.DecProto.typeUrl);