@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/esm/sparkdream/shield/v1/query.js

@@ -0,0 +1,2323 @@
+//@ts-nocheck
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params } from "./params";
+import { ShieldedOpRegistration, DayFunding, ShieldEpochState, PendingShieldedOp, TLEKeySet, VerificationKey, ShieldDecryptionShare, DKGState, DKGContribution } from "./types";
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * @name QueryParamsRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryParamsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * @name QueryParamsResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldedOpRequest() {
+    return {
+        messageTypeUrl: ""
+    };
+}
+/**
+ * @name QueryShieldedOpRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldedOpRequest
+ */
+export const QueryShieldedOpRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldedOpRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.messageTypeUrl !== "") {
+            writer.uint32(10).string(message.messageTypeUrl);
+        }
+        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 = createBaseQueryShieldedOpRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.messageTypeUrl = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryShieldedOpRequest();
+        message.messageTypeUrl = object.messageTypeUrl ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryShieldedOpRequest();
+        if (object.message_type_url !== undefined && object.message_type_url !== null) {
+            message.messageTypeUrl = object.message_type_url;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.message_type_url = message.messageTypeUrl === "" ? undefined : message.messageTypeUrl;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldedOpRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldedOpRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldedOpRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldedOpRequest",
+            value: QueryShieldedOpRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldedOpResponse() {
+    return {
+        registration: ShieldedOpRegistration.fromPartial({})
+    };
+}
+/**
+ * @name QueryShieldedOpResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldedOpResponse
+ */
+export const QueryShieldedOpResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldedOpResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.registration !== undefined) {
+            ShieldedOpRegistration.encode(message.registration, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryShieldedOpResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.registration = ShieldedOpRegistration.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryShieldedOpResponse();
+        message.registration = object.registration !== undefined && object.registration !== null ? ShieldedOpRegistration.fromPartial(object.registration) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryShieldedOpResponse();
+        if (object.registration !== undefined && object.registration !== null) {
+            message.registration = ShieldedOpRegistration.fromAmino(object.registration);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.registration = message.registration ? ShieldedOpRegistration.toAmino(message.registration) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldedOpResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldedOpResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldedOpResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldedOpResponse",
+            value: QueryShieldedOpResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldedOpsRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryShieldedOpsRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldedOpsRequest
+ */
+export const QueryShieldedOpsRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldedOpsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryShieldedOpsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryShieldedOpsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryShieldedOpsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldedOpsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldedOpsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldedOpsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldedOpsRequest",
+            value: QueryShieldedOpsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldedOpsResponse() {
+    return {
+        registrations: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryShieldedOpsResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldedOpsResponse
+ */
+export const QueryShieldedOpsResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldedOpsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.registrations) {
+            ShieldedOpRegistration.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseQueryShieldedOpsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.registrations.push(ShieldedOpRegistration.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryShieldedOpsResponse();
+        message.registrations = object.registrations?.map(e => ShieldedOpRegistration.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryShieldedOpsResponse();
+        message.registrations = object.registrations?.map(e => ShieldedOpRegistration.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.registrations) {
+            obj.registrations = message.registrations.map(e => e ? ShieldedOpRegistration.toAmino(e) : undefined);
+        }
+        else {
+            obj.registrations = message.registrations;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldedOpsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldedOpsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldedOpsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldedOpsResponse",
+            value: QueryShieldedOpsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryModuleBalanceRequest() {
+    return {};
+}
+/**
+ * @name QueryModuleBalanceRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryModuleBalanceRequest
+ */
+export const QueryModuleBalanceRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryModuleBalanceRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryModuleBalanceRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryModuleBalanceRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryModuleBalanceRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryModuleBalanceRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryModuleBalanceRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryModuleBalanceRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryModuleBalanceRequest",
+            value: QueryModuleBalanceRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryModuleBalanceResponse() {
+    return {
+        balance: Coin.fromPartial({})
+    };
+}
+/**
+ * @name QueryModuleBalanceResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryModuleBalanceResponse
+ */
+export const QueryModuleBalanceResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryModuleBalanceResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.balance !== undefined) {
+            Coin.encode(message.balance, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryModuleBalanceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.balance = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryModuleBalanceResponse();
+        message.balance = object.balance !== undefined && object.balance !== null ? Coin.fromPartial(object.balance) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryModuleBalanceResponse();
+        if (object.balance !== undefined && object.balance !== null) {
+            message.balance = Coin.fromAmino(object.balance);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.balance = message.balance ? Coin.toAmino(message.balance) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryModuleBalanceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryModuleBalanceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryModuleBalanceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryModuleBalanceResponse",
+            value: QueryModuleBalanceResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryNullifierUsedRequest() {
+    return {
+        domain: 0,
+        scope: BigInt(0),
+        nullifierHex: ""
+    };
+}
+/**
+ * @name QueryNullifierUsedRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryNullifierUsedRequest
+ */
+export const QueryNullifierUsedRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryNullifierUsedRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.domain !== 0) {
+            writer.uint32(8).uint32(message.domain);
+        }
+        if (message.scope !== BigInt(0)) {
+            writer.uint32(16).uint64(message.scope);
+        }
+        if (message.nullifierHex !== "") {
+            writer.uint32(26).string(message.nullifierHex);
+        }
+        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 = createBaseQueryNullifierUsedRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.domain = reader.uint32();
+                    break;
+                case 2:
+                    message.scope = reader.uint64();
+                    break;
+                case 3:
+                    message.nullifierHex = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryNullifierUsedRequest();
+        message.domain = object.domain ?? 0;
+        message.scope = object.scope !== undefined && object.scope !== null ? BigInt(object.scope.toString()) : BigInt(0);
+        message.nullifierHex = object.nullifierHex ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryNullifierUsedRequest();
+        if (object.domain !== undefined && object.domain !== null) {
+            message.domain = object.domain;
+        }
+        if (object.scope !== undefined && object.scope !== null) {
+            message.scope = BigInt(object.scope);
+        }
+        if (object.nullifier_hex !== undefined && object.nullifier_hex !== null) {
+            message.nullifierHex = object.nullifier_hex;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.domain = message.domain === 0 ? undefined : message.domain;
+        obj.scope = message.scope !== BigInt(0) ? message.scope?.toString() : undefined;
+        obj.nullifier_hex = message.nullifierHex === "" ? undefined : message.nullifierHex;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryNullifierUsedRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryNullifierUsedRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryNullifierUsedRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryNullifierUsedRequest",
+            value: QueryNullifierUsedRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryNullifierUsedResponse() {
+    return {
+        used: false,
+        usedAtHeight: BigInt(0)
+    };
+}
+/**
+ * @name QueryNullifierUsedResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryNullifierUsedResponse
+ */
+export const QueryNullifierUsedResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryNullifierUsedResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.used === true) {
+            writer.uint32(8).bool(message.used);
+        }
+        if (message.usedAtHeight !== BigInt(0)) {
+            writer.uint32(16).int64(message.usedAtHeight);
+        }
+        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 = createBaseQueryNullifierUsedResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.used = reader.bool();
+                    break;
+                case 2:
+                    message.usedAtHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryNullifierUsedResponse();
+        message.used = object.used ?? false;
+        message.usedAtHeight = object.usedAtHeight !== undefined && object.usedAtHeight !== null ? BigInt(object.usedAtHeight.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryNullifierUsedResponse();
+        if (object.used !== undefined && object.used !== null) {
+            message.used = object.used;
+        }
+        if (object.used_at_height !== undefined && object.used_at_height !== null) {
+            message.usedAtHeight = BigInt(object.used_at_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.used = message.used === false ? undefined : message.used;
+        obj.used_at_height = message.usedAtHeight !== BigInt(0) ? message.usedAtHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryNullifierUsedResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryNullifierUsedResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryNullifierUsedResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryNullifierUsedResponse",
+            value: QueryNullifierUsedResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDayFundingRequest() {
+    return {
+        day: BigInt(0)
+    };
+}
+/**
+ * @name QueryDayFundingRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDayFundingRequest
+ */
+export const QueryDayFundingRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryDayFundingRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.day !== BigInt(0)) {
+            writer.uint32(8).uint64(message.day);
+        }
+        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 = createBaseQueryDayFundingRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.day = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDayFundingRequest();
+        message.day = object.day !== undefined && object.day !== null ? BigInt(object.day.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDayFundingRequest();
+        if (object.day !== undefined && object.day !== null) {
+            message.day = BigInt(object.day);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.day = message.day !== BigInt(0) ? message.day?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDayFundingRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDayFundingRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDayFundingRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDayFundingRequest",
+            value: QueryDayFundingRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDayFundingResponse() {
+    return {
+        dayFunding: DayFunding.fromPartial({})
+    };
+}
+/**
+ * @name QueryDayFundingResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDayFundingResponse
+ */
+export const QueryDayFundingResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryDayFundingResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.dayFunding !== undefined) {
+            DayFunding.encode(message.dayFunding, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryDayFundingResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.dayFunding = DayFunding.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDayFundingResponse();
+        message.dayFunding = object.dayFunding !== undefined && object.dayFunding !== null ? DayFunding.fromPartial(object.dayFunding) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDayFundingResponse();
+        if (object.day_funding !== undefined && object.day_funding !== null) {
+            message.dayFunding = DayFunding.fromAmino(object.day_funding);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.day_funding = message.dayFunding ? DayFunding.toAmino(message.dayFunding) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDayFundingResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDayFundingResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDayFundingResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDayFundingResponse",
+            value: QueryDayFundingResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldEpochRequest() {
+    return {};
+}
+/**
+ * @name QueryShieldEpochRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldEpochRequest
+ */
+export const QueryShieldEpochRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldEpochRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryShieldEpochRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryShieldEpochRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryShieldEpochRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldEpochRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldEpochRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldEpochRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldEpochRequest",
+            value: QueryShieldEpochRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryShieldEpochResponse() {
+    return {
+        epochState: ShieldEpochState.fromPartial({})
+    };
+}
+/**
+ * @name QueryShieldEpochResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryShieldEpochResponse
+ */
+export const QueryShieldEpochResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryShieldEpochResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epochState !== undefined) {
+            ShieldEpochState.encode(message.epochState, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryShieldEpochResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epochState = ShieldEpochState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryShieldEpochResponse();
+        message.epochState = object.epochState !== undefined && object.epochState !== null ? ShieldEpochState.fromPartial(object.epochState) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryShieldEpochResponse();
+        if (object.epoch_state !== undefined && object.epoch_state !== null) {
+            message.epochState = ShieldEpochState.fromAmino(object.epoch_state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch_state = message.epochState ? ShieldEpochState.toAmino(message.epochState) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryShieldEpochResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryShieldEpochResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryShieldEpochResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryShieldEpochResponse",
+            value: QueryShieldEpochResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingOpsRequest() {
+    return {
+        epoch: BigInt(0),
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPendingOpsRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryPendingOpsRequest
+ */
+export const QueryPendingOpsRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryPendingOpsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseQueryPendingOpsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPendingOpsRequest();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPendingOpsRequest();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingOpsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingOpsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingOpsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryPendingOpsRequest",
+            value: QueryPendingOpsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingOpsResponse() {
+    return {
+        pendingOps: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPendingOpsResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryPendingOpsResponse
+ */
+export const QueryPendingOpsResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryPendingOpsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.pendingOps) {
+            PendingShieldedOp.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseQueryPendingOpsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pendingOps.push(PendingShieldedOp.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPendingOpsResponse();
+        message.pendingOps = object.pendingOps?.map(e => PendingShieldedOp.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPendingOpsResponse();
+        message.pendingOps = object.pending_ops?.map(e => PendingShieldedOp.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.pendingOps) {
+            obj.pending_ops = message.pendingOps.map(e => e ? PendingShieldedOp.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_ops = message.pendingOps;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingOpsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingOpsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingOpsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryPendingOpsResponse",
+            value: QueryPendingOpsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingOpCountRequest() {
+    return {};
+}
+/**
+ * @name QueryPendingOpCountRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryPendingOpCountRequest
+ */
+export const QueryPendingOpCountRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryPendingOpCountRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryPendingOpCountRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryPendingOpCountRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryPendingOpCountRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingOpCountRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingOpCountRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingOpCountRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryPendingOpCountRequest",
+            value: QueryPendingOpCountRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingOpCountResponse() {
+    return {
+        count: BigInt(0)
+    };
+}
+/**
+ * @name QueryPendingOpCountResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryPendingOpCountResponse
+ */
+export const QueryPendingOpCountResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryPendingOpCountResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.count !== BigInt(0)) {
+            writer.uint32(8).uint64(message.count);
+        }
+        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 = createBaseQueryPendingOpCountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.count = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPendingOpCountResponse();
+        message.count = object.count !== undefined && object.count !== null ? BigInt(object.count.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPendingOpCountResponse();
+        if (object.count !== undefined && object.count !== null) {
+            message.count = BigInt(object.count);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.count = message.count !== BigInt(0) ? message.count?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingOpCountResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingOpCountResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingOpCountResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryPendingOpCountResponse",
+            value: QueryPendingOpCountResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEMasterPublicKeyRequest() {
+    return {};
+}
+/**
+ * @name QueryTLEMasterPublicKeyRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEMasterPublicKeyRequest
+ */
+export const QueryTLEMasterPublicKeyRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEMasterPublicKeyRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryTLEMasterPublicKeyRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryTLEMasterPublicKeyRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryTLEMasterPublicKeyRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEMasterPublicKeyRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEMasterPublicKeyRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEMasterPublicKeyRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEMasterPublicKeyRequest",
+            value: QueryTLEMasterPublicKeyRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEMasterPublicKeyResponse() {
+    return {
+        masterPublicKey: new Uint8Array()
+    };
+}
+/**
+ * @name QueryTLEMasterPublicKeyResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEMasterPublicKeyResponse
+ */
+export const QueryTLEMasterPublicKeyResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEMasterPublicKeyResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.masterPublicKey.length !== 0) {
+            writer.uint32(10).bytes(message.masterPublicKey);
+        }
+        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 = createBaseQueryTLEMasterPublicKeyResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.masterPublicKey = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTLEMasterPublicKeyResponse();
+        message.masterPublicKey = object.masterPublicKey ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryTLEMasterPublicKeyResponse();
+        if (object.master_public_key !== undefined && object.master_public_key !== null) {
+            message.masterPublicKey = bytesFromBase64(object.master_public_key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.master_public_key = message.masterPublicKey ? base64FromBytes(message.masterPublicKey) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEMasterPublicKeyResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEMasterPublicKeyResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEMasterPublicKeyResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEMasterPublicKeyResponse",
+            value: QueryTLEMasterPublicKeyResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEKeySetRequest() {
+    return {};
+}
+/**
+ * @name QueryTLEKeySetRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEKeySetRequest
+ */
+export const QueryTLEKeySetRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEKeySetRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryTLEKeySetRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryTLEKeySetRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryTLEKeySetRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEKeySetRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEKeySetRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEKeySetRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEKeySetRequest",
+            value: QueryTLEKeySetRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEKeySetResponse() {
+    return {
+        keySet: TLEKeySet.fromPartial({})
+    };
+}
+/**
+ * @name QueryTLEKeySetResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEKeySetResponse
+ */
+export const QueryTLEKeySetResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEKeySetResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.keySet !== undefined) {
+            TLEKeySet.encode(message.keySet, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryTLEKeySetResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.keySet = TLEKeySet.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTLEKeySetResponse();
+        message.keySet = object.keySet !== undefined && object.keySet !== null ? TLEKeySet.fromPartial(object.keySet) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryTLEKeySetResponse();
+        if (object.key_set !== undefined && object.key_set !== null) {
+            message.keySet = TLEKeySet.fromAmino(object.key_set);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key_set = message.keySet ? TLEKeySet.toAmino(message.keySet) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEKeySetResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEKeySetResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEKeySetResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEKeySetResponse",
+            value: QueryTLEKeySetResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryVerificationKeyRequest() {
+    return {
+        circuitId: ""
+    };
+}
+/**
+ * @name QueryVerificationKeyRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryVerificationKeyRequest
+ */
+export const QueryVerificationKeyRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryVerificationKeyRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.circuitId !== "") {
+            writer.uint32(10).string(message.circuitId);
+        }
+        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 = createBaseQueryVerificationKeyRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.circuitId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryVerificationKeyRequest();
+        message.circuitId = object.circuitId ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryVerificationKeyRequest();
+        if (object.circuit_id !== undefined && object.circuit_id !== null) {
+            message.circuitId = object.circuit_id;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.circuit_id = message.circuitId === "" ? undefined : message.circuitId;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryVerificationKeyRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryVerificationKeyRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryVerificationKeyRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryVerificationKeyRequest",
+            value: QueryVerificationKeyRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryVerificationKeyResponse() {
+    return {
+        verificationKey: VerificationKey.fromPartial({})
+    };
+}
+/**
+ * @name QueryVerificationKeyResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryVerificationKeyResponse
+ */
+export const QueryVerificationKeyResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryVerificationKeyResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.verificationKey !== undefined) {
+            VerificationKey.encode(message.verificationKey, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryVerificationKeyResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.verificationKey = VerificationKey.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryVerificationKeyResponse();
+        message.verificationKey = object.verificationKey !== undefined && object.verificationKey !== null ? VerificationKey.fromPartial(object.verificationKey) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryVerificationKeyResponse();
+        if (object.verification_key !== undefined && object.verification_key !== null) {
+            message.verificationKey = VerificationKey.fromAmino(object.verification_key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.verification_key = message.verificationKey ? VerificationKey.toAmino(message.verificationKey) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryVerificationKeyResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryVerificationKeyResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryVerificationKeyResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryVerificationKeyResponse",
+            value: QueryVerificationKeyResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEMissCountRequest() {
+    return {
+        validatorAddress: ""
+    };
+}
+/**
+ * @name QueryTLEMissCountRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEMissCountRequest
+ */
+export const QueryTLEMissCountRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEMissCountRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress !== "") {
+            writer.uint32(10).string(message.validatorAddress);
+        }
+        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 = createBaseQueryTLEMissCountRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTLEMissCountRequest();
+        message.validatorAddress = object.validatorAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryTLEMissCountRequest();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = object.validator_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEMissCountRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEMissCountRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEMissCountRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEMissCountRequest",
+            value: QueryTLEMissCountRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryTLEMissCountResponse() {
+    return {
+        missCount: BigInt(0)
+    };
+}
+/**
+ * @name QueryTLEMissCountResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryTLEMissCountResponse
+ */
+export const QueryTLEMissCountResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryTLEMissCountResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.missCount !== BigInt(0)) {
+            writer.uint32(8).uint64(message.missCount);
+        }
+        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 = createBaseQueryTLEMissCountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.missCount = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTLEMissCountResponse();
+        message.missCount = object.missCount !== undefined && object.missCount !== null ? BigInt(object.missCount.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryTLEMissCountResponse();
+        if (object.miss_count !== undefined && object.miss_count !== null) {
+            message.missCount = BigInt(object.miss_count);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.miss_count = message.missCount !== BigInt(0) ? message.missCount?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryTLEMissCountResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryTLEMissCountResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTLEMissCountResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryTLEMissCountResponse",
+            value: QueryTLEMissCountResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDecryptionSharesRequest() {
+    return {
+        epoch: BigInt(0)
+    };
+}
+/**
+ * @name QueryDecryptionSharesRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDecryptionSharesRequest
+ */
+export const QueryDecryptionSharesRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryDecryptionSharesRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        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 = createBaseQueryDecryptionSharesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDecryptionSharesRequest();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDecryptionSharesRequest();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDecryptionSharesRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDecryptionSharesRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDecryptionSharesRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDecryptionSharesRequest",
+            value: QueryDecryptionSharesRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDecryptionSharesResponse() {
+    return {
+        shares: []
+    };
+}
+/**
+ * @name QueryDecryptionSharesResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDecryptionSharesResponse
+ */
+export const QueryDecryptionSharesResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryDecryptionSharesResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.shares) {
+            ShieldDecryptionShare.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryDecryptionSharesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.shares.push(ShieldDecryptionShare.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDecryptionSharesResponse();
+        message.shares = object.shares?.map(e => ShieldDecryptionShare.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDecryptionSharesResponse();
+        message.shares = object.shares?.map(e => ShieldDecryptionShare.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.shares) {
+            obj.shares = message.shares.map(e => e ? ShieldDecryptionShare.toAmino(e) : undefined);
+        }
+        else {
+            obj.shares = message.shares;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDecryptionSharesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDecryptionSharesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDecryptionSharesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDecryptionSharesResponse",
+            value: QueryDecryptionSharesResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryIdentityRateLimitRequest() {
+    return {
+        rateLimitNullifierHex: ""
+    };
+}
+/**
+ * @name QueryIdentityRateLimitRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryIdentityRateLimitRequest
+ */
+export const QueryIdentityRateLimitRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryIdentityRateLimitRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.rateLimitNullifierHex !== "") {
+            writer.uint32(10).string(message.rateLimitNullifierHex);
+        }
+        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 = createBaseQueryIdentityRateLimitRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.rateLimitNullifierHex = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryIdentityRateLimitRequest();
+        message.rateLimitNullifierHex = object.rateLimitNullifierHex ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryIdentityRateLimitRequest();
+        if (object.rate_limit_nullifier_hex !== undefined && object.rate_limit_nullifier_hex !== null) {
+            message.rateLimitNullifierHex = object.rate_limit_nullifier_hex;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.rate_limit_nullifier_hex = message.rateLimitNullifierHex === "" ? undefined : message.rateLimitNullifierHex;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryIdentityRateLimitRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryIdentityRateLimitRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryIdentityRateLimitRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryIdentityRateLimitRequest",
+            value: QueryIdentityRateLimitRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryIdentityRateLimitResponse() {
+    return {
+        usedCount: BigInt(0),
+        maxCount: BigInt(0),
+        remaining: BigInt(0)
+    };
+}
+/**
+ * @name QueryIdentityRateLimitResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryIdentityRateLimitResponse
+ */
+export const QueryIdentityRateLimitResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryIdentityRateLimitResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.usedCount !== BigInt(0)) {
+            writer.uint32(8).uint64(message.usedCount);
+        }
+        if (message.maxCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.maxCount);
+        }
+        if (message.remaining !== BigInt(0)) {
+            writer.uint32(24).uint64(message.remaining);
+        }
+        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 = createBaseQueryIdentityRateLimitResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.usedCount = reader.uint64();
+                    break;
+                case 2:
+                    message.maxCount = reader.uint64();
+                    break;
+                case 3:
+                    message.remaining = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryIdentityRateLimitResponse();
+        message.usedCount = object.usedCount !== undefined && object.usedCount !== null ? BigInt(object.usedCount.toString()) : BigInt(0);
+        message.maxCount = object.maxCount !== undefined && object.maxCount !== null ? BigInt(object.maxCount.toString()) : BigInt(0);
+        message.remaining = object.remaining !== undefined && object.remaining !== null ? BigInt(object.remaining.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryIdentityRateLimitResponse();
+        if (object.used_count !== undefined && object.used_count !== null) {
+            message.usedCount = BigInt(object.used_count);
+        }
+        if (object.max_count !== undefined && object.max_count !== null) {
+            message.maxCount = BigInt(object.max_count);
+        }
+        if (object.remaining !== undefined && object.remaining !== null) {
+            message.remaining = BigInt(object.remaining);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.used_count = message.usedCount !== BigInt(0) ? message.usedCount?.toString() : undefined;
+        obj.max_count = message.maxCount !== BigInt(0) ? message.maxCount?.toString() : undefined;
+        obj.remaining = message.remaining !== BigInt(0) ? message.remaining?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryIdentityRateLimitResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryIdentityRateLimitResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryIdentityRateLimitResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryIdentityRateLimitResponse",
+            value: QueryIdentityRateLimitResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDKGStateRequest() {
+    return {};
+}
+/**
+ * @name QueryDKGStateRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDKGStateRequest
+ */
+export const QueryDKGStateRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryDKGStateRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryDKGStateRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryDKGStateRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryDKGStateRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDKGStateRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDKGStateRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDKGStateRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDKGStateRequest",
+            value: QueryDKGStateRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDKGStateResponse() {
+    return {
+        dkgState: DKGState.fromPartial({})
+    };
+}
+/**
+ * @name QueryDKGStateResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDKGStateResponse
+ */
+export const QueryDKGStateResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryDKGStateResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.dkgState !== undefined) {
+            DKGState.encode(message.dkgState, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryDKGStateResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.dkgState = DKGState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDKGStateResponse();
+        message.dkgState = object.dkgState !== undefined && object.dkgState !== null ? DKGState.fromPartial(object.dkgState) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDKGStateResponse();
+        if (object.dkg_state !== undefined && object.dkg_state !== null) {
+            message.dkgState = DKGState.fromAmino(object.dkg_state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.dkg_state = message.dkgState ? DKGState.toAmino(message.dkgState) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDKGStateResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDKGStateResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDKGStateResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDKGStateResponse",
+            value: QueryDKGStateResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDKGContributionsRequest() {
+    return {};
+}
+/**
+ * @name QueryDKGContributionsRequest
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDKGContributionsRequest
+ */
+export const QueryDKGContributionsRequest = {
+    typeUrl: "/sparkdream.shield.v1.QueryDKGContributionsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseQueryDKGContributionsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryDKGContributionsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryDKGContributionsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDKGContributionsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDKGContributionsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDKGContributionsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDKGContributionsRequest",
+            value: QueryDKGContributionsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryDKGContributionsResponse() {
+    return {
+        contributions: []
+    };
+}
+/**
+ * @name QueryDKGContributionsResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.QueryDKGContributionsResponse
+ */
+export const QueryDKGContributionsResponse = {
+    typeUrl: "/sparkdream.shield.v1.QueryDKGContributionsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.contributions) {
+            DKGContribution.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryDKGContributionsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contributions.push(DKGContribution.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryDKGContributionsResponse();
+        message.contributions = object.contributions?.map(e => DKGContribution.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryDKGContributionsResponse();
+        message.contributions = object.contributions?.map(e => DKGContribution.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.contributions) {
+            obj.contributions = message.contributions.map(e => e ? DKGContribution.toAmino(e) : undefined);
+        }
+        else {
+            obj.contributions = message.contributions;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryDKGContributionsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryDKGContributionsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryDKGContributionsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.QueryDKGContributionsResponse",
+            value: QueryDKGContributionsResponse.encode(message).finish()
+        };
+    }
+};