@xpla/xpla-react 1.7.0-beta.0

package/src/xpla/volunteer/v1beta1/query.ts

@@ -0,0 +1,160 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequest {}
+export interface QueryVolunteerValidatorsRequestProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+  value: Uint8Array;
+}
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequestAmino {}
+export interface QueryVolunteerValidatorsRequestAminoMsg {
+  type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+  value: QueryVolunteerValidatorsRequestAmino;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponse {
+  volunteerValidators: string[];
+}
+export interface QueryVolunteerValidatorsResponseProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+  value: Uint8Array;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponseAmino {
+  volunteer_validators: string[];
+}
+export interface QueryVolunteerValidatorsResponseAminoMsg {
+  type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+  value: QueryVolunteerValidatorsResponseAmino;
+}
+function createBaseQueryVolunteerValidatorsRequest(): QueryVolunteerValidatorsRequest {
+  return {};
+}
+export const QueryVolunteerValidatorsRequest = {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+  is(o: any): o is QueryVolunteerValidatorsRequest {
+    return o && o.$typeUrl === QueryVolunteerValidatorsRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryVolunteerValidatorsRequestAmino {
+    return o && o.$typeUrl === QueryVolunteerValidatorsRequest.typeUrl;
+  },
+  encode(_: QueryVolunteerValidatorsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryVolunteerValidatorsRequest>): QueryVolunteerValidatorsRequest {
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    return message;
+  },
+  fromAmino(_: QueryVolunteerValidatorsRequestAmino): QueryVolunteerValidatorsRequest {
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    return message;
+  },
+  toAmino(_: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryVolunteerValidatorsRequestAminoMsg): QueryVolunteerValidatorsRequest {
+    return QueryVolunteerValidatorsRequest.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryVolunteerValidatorsRequestProtoMsg): QueryVolunteerValidatorsRequest {
+    return QueryVolunteerValidatorsRequest.decode(message.value);
+  },
+  toProto(message: QueryVolunteerValidatorsRequest): Uint8Array {
+    return QueryVolunteerValidatorsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+      value: QueryVolunteerValidatorsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryVolunteerValidatorsRequest.typeUrl, QueryVolunteerValidatorsRequest);
+function createBaseQueryVolunteerValidatorsResponse(): QueryVolunteerValidatorsResponse {
+  return {
+    volunteerValidators: []
+  };
+}
+export const QueryVolunteerValidatorsResponse = {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+  is(o: any): o is QueryVolunteerValidatorsResponse {
+    return o && (o.$typeUrl === QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteerValidators) && (!o.volunteerValidators.length || typeof o.volunteerValidators[0] === "string"));
+  },
+  isAmino(o: any): o is QueryVolunteerValidatorsResponseAmino {
+    return o && (o.$typeUrl === QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteer_validators) && (!o.volunteer_validators.length || typeof o.volunteer_validators[0] === "string"));
+  },
+  encode(message: QueryVolunteerValidatorsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.volunteerValidators) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.volunteerValidators.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryVolunteerValidatorsResponse>): QueryVolunteerValidatorsResponse {
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    message.volunteerValidators = object.volunteerValidators?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: QueryVolunteerValidatorsResponseAmino): QueryVolunteerValidatorsResponse {
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    message.volunteerValidators = object.volunteer_validators?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseAmino {
+    const obj: any = {};
+    if (message.volunteerValidators) {
+      obj.volunteer_validators = message.volunteerValidators.map(e => e);
+    } else {
+      obj.volunteer_validators = message.volunteerValidators;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: QueryVolunteerValidatorsResponseAminoMsg): QueryVolunteerValidatorsResponse {
+    return QueryVolunteerValidatorsResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryVolunteerValidatorsResponseProtoMsg): QueryVolunteerValidatorsResponse {
+    return QueryVolunteerValidatorsResponse.decode(message.value);
+  },
+  toProto(message: QueryVolunteerValidatorsResponse): Uint8Array {
+    return QueryVolunteerValidatorsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+      value: QueryVolunteerValidatorsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryVolunteerValidatorsResponse.typeUrl, QueryVolunteerValidatorsResponse);

package/src/xpla/volunteer/v1beta1/tx.registry.ts

@@ -0,0 +1,47 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgRegisterVolunteerValidator, MsgUnregisterVolunteerValidator } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator", MsgRegisterVolunteerValidator], ["/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator", MsgUnregisterVolunteerValidator]];
+export const MessageComposer = {
+  encoded: {
+    registerVolunteerValidator(value: MsgRegisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator",
+        value: MsgRegisterVolunteerValidator.encode(value).finish()
+      };
+    },
+    unregisterVolunteerValidator(value: MsgUnregisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator",
+        value: MsgUnregisterVolunteerValidator.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    registerVolunteerValidator(value: MsgRegisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator",
+        value
+      };
+    },
+    unregisterVolunteerValidator(value: MsgUnregisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    registerVolunteerValidator(value: MsgRegisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator",
+        value: MsgRegisterVolunteerValidator.fromPartial(value)
+      };
+    },
+    unregisterVolunteerValidator(value: MsgUnregisterVolunteerValidator) {
+      return {
+        typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator",
+        value: MsgUnregisterVolunteerValidator.fromPartial(value)
+      };
+    }
+  }
+};

package/src/xpla/volunteer/v1beta1/tx.rpc.func.ts

@@ -0,0 +1,22 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { buildUseMutation } from "../../../react-query";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgRegisterVolunteerValidator, MsgUnregisterVolunteerValidator } from "./tx";
+export const createRegisterVolunteerValidator = (clientResolver?: SigningClientResolver) => buildTx<MsgRegisterVolunteerValidator>({
+  clientResolver,
+  typeUrl: MsgRegisterVolunteerValidator.typeUrl,
+  encoders: toEncoders(MsgRegisterVolunteerValidator),
+  converters: toConverters(MsgRegisterVolunteerValidator)
+});
+export const useRegisterVolunteerValidator = buildUseMutation<MsgRegisterVolunteerValidator, Error>({
+  builderMutationFn: createRegisterVolunteerValidator
+});
+export const createUnregisterVolunteerValidator = (clientResolver?: SigningClientResolver) => buildTx<MsgUnregisterVolunteerValidator>({
+  clientResolver,
+  typeUrl: MsgUnregisterVolunteerValidator.typeUrl,
+  encoders: toEncoders(MsgUnregisterVolunteerValidator),
+  converters: toConverters(MsgUnregisterVolunteerValidator)
+});
+export const useUnregisterVolunteerValidator = buildUseMutation<MsgUnregisterVolunteerValidator, Error>({
+  builderMutationFn: createUnregisterVolunteerValidator
+});

package/src/xpla/volunteer/v1beta1/tx.ts

@@ -0,0 +1,448 @@
+import { Description, DescriptionAmino } from "../../../cosmos/staking/v1beta1/staking";
+import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { encodePubkey, decodePubkey } from "@cosmjs/proto-signing";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * MsgRegisterVolunteerValidator defines a message to register a new volunteer
+ * validator.
+ */
+export interface MsgRegisterVolunteerValidator {
+  /** authority is the address of the governance account. */
+  authority: string;
+  validatorDescription: Description;
+  delegatorAddress: string;
+  validatorAddress: string;
+  pubkey?: Any | undefined;
+  amount: Coin;
+}
+export interface MsgRegisterVolunteerValidatorProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator";
+  value: Uint8Array;
+}
+export type MsgRegisterVolunteerValidatorEncoded = Omit<MsgRegisterVolunteerValidator, "pubkey"> & {
+  pubkey?: AnyProtoMsg | undefined;
+};
+/**
+ * MsgRegisterVolunteerValidator defines a message to register a new volunteer
+ * validator.
+ */
+export interface MsgRegisterVolunteerValidatorAmino {
+  /** authority is the address of the governance account. */
+  authority: string;
+  validator_description: DescriptionAmino;
+  delegator_address: string;
+  validator_address: string;
+  pubkey?: AnyAmino;
+  amount: CoinAmino;
+}
+export interface MsgRegisterVolunteerValidatorAminoMsg {
+  type: "xpladev/MsgRegisterVolunteerValidator";
+  value: MsgRegisterVolunteerValidatorAmino;
+}
+/**
+ * MsgRegisterVolunteerValidatorResponse defines the RegisterVolunteerValidator
+ * response.
+ */
+export interface MsgRegisterVolunteerValidatorResponse {}
+export interface MsgRegisterVolunteerValidatorResponseProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgRegisterVolunteerValidatorResponse defines the RegisterVolunteerValidator
+ * response.
+ */
+export interface MsgRegisterVolunteerValidatorResponseAmino {}
+export interface MsgRegisterVolunteerValidatorResponseAminoMsg {
+  type: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse";
+  value: MsgRegisterVolunteerValidatorResponseAmino;
+}
+/**
+ * MsgUnregisterVolunteerValidator defines a message to unregister a volunteer
+ * validator.
+ */
+export interface MsgUnregisterVolunteerValidator {
+  /** authority is the address of the governance account. */
+  authority: string;
+  validatorAddress: string;
+}
+export interface MsgUnregisterVolunteerValidatorProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator";
+  value: Uint8Array;
+}
+/**
+ * MsgUnregisterVolunteerValidator defines a message to unregister a volunteer
+ * validator.
+ */
+export interface MsgUnregisterVolunteerValidatorAmino {
+  /** authority is the address of the governance account. */
+  authority: string;
+  validator_address: string;
+}
+export interface MsgUnregisterVolunteerValidatorAminoMsg {
+  type: "xpladev/MsgUnregisterVolunteerValidator";
+  value: MsgUnregisterVolunteerValidatorAmino;
+}
+/**
+ * MsgUnregisterVolunteerValidatorResponse defines the
+ * UnregisterVolunteerValidator response.
+ */
+export interface MsgUnregisterVolunteerValidatorResponse {}
+export interface MsgUnregisterVolunteerValidatorResponseProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgUnregisterVolunteerValidatorResponse defines the
+ * UnregisterVolunteerValidator response.
+ */
+export interface MsgUnregisterVolunteerValidatorResponseAmino {}
+export interface MsgUnregisterVolunteerValidatorResponseAminoMsg {
+  type: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse";
+  value: MsgUnregisterVolunteerValidatorResponseAmino;
+}
+function createBaseMsgRegisterVolunteerValidator(): MsgRegisterVolunteerValidator {
+  return {
+    authority: "",
+    validatorDescription: Description.fromPartial({}),
+    delegatorAddress: "",
+    validatorAddress: "",
+    pubkey: undefined,
+    amount: Coin.fromPartial({})
+  };
+}
+export const MsgRegisterVolunteerValidator = {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator",
+  aminoType: "xpladev/MsgRegisterVolunteerValidator",
+  is(o: any): o is MsgRegisterVolunteerValidator {
+    return o && (o.$typeUrl === MsgRegisterVolunteerValidator.typeUrl || typeof o.authority === "string" && Description.is(o.validatorDescription) && typeof o.delegatorAddress === "string" && typeof o.validatorAddress === "string" && Coin.is(o.amount));
+  },
+  isAmino(o: any): o is MsgRegisterVolunteerValidatorAmino {
+    return o && (o.$typeUrl === MsgRegisterVolunteerValidator.typeUrl || typeof o.authority === "string" && Description.isAmino(o.validator_description) && typeof o.delegator_address === "string" && typeof o.validator_address === "string" && Coin.isAmino(o.amount));
+  },
+  encode(message: MsgRegisterVolunteerValidator, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.validatorDescription !== undefined) {
+      Description.encode(message.validatorDescription, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.delegatorAddress !== "") {
+      writer.uint32(26).string(message.delegatorAddress);
+    }
+    if (message.validatorAddress !== "") {
+      writer.uint32(34).string(message.validatorAddress);
+    }
+    if (message.pubkey !== undefined) {
+      Any.encode(GlobalDecoderRegistry.wrapAny(message.pubkey), writer.uint32(42).fork()).ldelim();
+    }
+    if (message.amount !== undefined) {
+      Coin.encode(message.amount, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterVolunteerValidator {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRegisterVolunteerValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        case 2:
+          message.validatorDescription = Description.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.delegatorAddress = reader.string();
+          break;
+        case 4:
+          message.validatorAddress = reader.string();
+          break;
+        case 5:
+          message.pubkey = GlobalDecoderRegistry.unwrapAny(reader);
+          break;
+        case 6:
+          message.amount = Coin.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<MsgRegisterVolunteerValidator>): MsgRegisterVolunteerValidator {
+    const message = createBaseMsgRegisterVolunteerValidator();
+    message.authority = object.authority ?? "";
+    message.validatorDescription = object.validatorDescription !== undefined && object.validatorDescription !== null ? Description.fromPartial(object.validatorDescription) : undefined;
+    message.delegatorAddress = object.delegatorAddress ?? "";
+    message.validatorAddress = object.validatorAddress ?? "";
+    message.pubkey = object.pubkey !== undefined && object.pubkey !== null ? GlobalDecoderRegistry.fromPartial(object.pubkey) : undefined;
+    message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgRegisterVolunteerValidatorAmino): MsgRegisterVolunteerValidator {
+    const message = createBaseMsgRegisterVolunteerValidator();
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    if (object.validator_description !== undefined && object.validator_description !== null) {
+      message.validatorDescription = Description.fromAmino(object.validator_description);
+    }
+    if (object.delegator_address !== undefined && object.delegator_address !== null) {
+      message.delegatorAddress = object.delegator_address;
+    }
+    if (object.validator_address !== undefined && object.validator_address !== null) {
+      message.validatorAddress = object.validator_address;
+    }
+    if (object.pubkey !== undefined && object.pubkey !== null) {
+      message.pubkey = encodePubkey(object.pubkey);
+    }
+    if (object.amount !== undefined && object.amount !== null) {
+      message.amount = Coin.fromAmino(object.amount);
+    }
+    return message;
+  },
+  toAmino(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorAmino {
+    const obj: any = {};
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    obj.validator_description = message.validatorDescription ? Description.toAmino(message.validatorDescription) : Description.toAmino(Description.fromPartial({}));
+    obj.delegator_address = message.delegatorAddress === "" ? undefined : message.delegatorAddress;
+    obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+    obj.pubkey = message.pubkey ? decodePubkey(message.pubkey) : undefined;
+    obj.amount = message.amount ? Coin.toAmino(message.amount) : Coin.toAmino(Coin.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: MsgRegisterVolunteerValidatorAminoMsg): MsgRegisterVolunteerValidator {
+    return MsgRegisterVolunteerValidator.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorAminoMsg {
+    return {
+      type: "xpladev/MsgRegisterVolunteerValidator",
+      value: MsgRegisterVolunteerValidator.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgRegisterVolunteerValidatorProtoMsg): MsgRegisterVolunteerValidator {
+    return MsgRegisterVolunteerValidator.decode(message.value);
+  },
+  toProto(message: MsgRegisterVolunteerValidator): Uint8Array {
+    return MsgRegisterVolunteerValidator.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator",
+      value: MsgRegisterVolunteerValidator.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgRegisterVolunteerValidator.typeUrl, MsgRegisterVolunteerValidator);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRegisterVolunteerValidator.aminoType, MsgRegisterVolunteerValidator.typeUrl);
+function createBaseMsgRegisterVolunteerValidatorResponse(): MsgRegisterVolunteerValidatorResponse {
+  return {};
+}
+export const MsgRegisterVolunteerValidatorResponse = {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse",
+  is(o: any): o is MsgRegisterVolunteerValidatorResponse {
+    return o && o.$typeUrl === MsgRegisterVolunteerValidatorResponse.typeUrl;
+  },
+  isAmino(o: any): o is MsgRegisterVolunteerValidatorResponseAmino {
+    return o && o.$typeUrl === MsgRegisterVolunteerValidatorResponse.typeUrl;
+  },
+  encode(_: MsgRegisterVolunteerValidatorResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterVolunteerValidatorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRegisterVolunteerValidatorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<MsgRegisterVolunteerValidatorResponse>): MsgRegisterVolunteerValidatorResponse {
+    const message = createBaseMsgRegisterVolunteerValidatorResponse();
+    return message;
+  },
+  fromAmino(_: MsgRegisterVolunteerValidatorResponseAmino): MsgRegisterVolunteerValidatorResponse {
+    const message = createBaseMsgRegisterVolunteerValidatorResponse();
+    return message;
+  },
+  toAmino(_: MsgRegisterVolunteerValidatorResponse): MsgRegisterVolunteerValidatorResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgRegisterVolunteerValidatorResponseAminoMsg): MsgRegisterVolunteerValidatorResponse {
+    return MsgRegisterVolunteerValidatorResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: MsgRegisterVolunteerValidatorResponseProtoMsg): MsgRegisterVolunteerValidatorResponse {
+    return MsgRegisterVolunteerValidatorResponse.decode(message.value);
+  },
+  toProto(message: MsgRegisterVolunteerValidatorResponse): Uint8Array {
+    return MsgRegisterVolunteerValidatorResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRegisterVolunteerValidatorResponse): MsgRegisterVolunteerValidatorResponseProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse",
+      value: MsgRegisterVolunteerValidatorResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgRegisterVolunteerValidatorResponse.typeUrl, MsgRegisterVolunteerValidatorResponse);
+function createBaseMsgUnregisterVolunteerValidator(): MsgUnregisterVolunteerValidator {
+  return {
+    authority: "",
+    validatorAddress: ""
+  };
+}
+export const MsgUnregisterVolunteerValidator = {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator",
+  aminoType: "xpladev/MsgUnregisterVolunteerValidator",
+  is(o: any): o is MsgUnregisterVolunteerValidator {
+    return o && (o.$typeUrl === MsgUnregisterVolunteerValidator.typeUrl || typeof o.authority === "string" && typeof o.validatorAddress === "string");
+  },
+  isAmino(o: any): o is MsgUnregisterVolunteerValidatorAmino {
+    return o && (o.$typeUrl === MsgUnregisterVolunteerValidator.typeUrl || typeof o.authority === "string" && typeof o.validator_address === "string");
+  },
+  encode(message: MsgUnregisterVolunteerValidator, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.validatorAddress !== "") {
+      writer.uint32(18).string(message.validatorAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUnregisterVolunteerValidator {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnregisterVolunteerValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        case 2:
+          message.validatorAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<MsgUnregisterVolunteerValidator>): MsgUnregisterVolunteerValidator {
+    const message = createBaseMsgUnregisterVolunteerValidator();
+    message.authority = object.authority ?? "";
+    message.validatorAddress = object.validatorAddress ?? "";
+    return message;
+  },
+  fromAmino(object: MsgUnregisterVolunteerValidatorAmino): MsgUnregisterVolunteerValidator {
+    const message = createBaseMsgUnregisterVolunteerValidator();
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    if (object.validator_address !== undefined && object.validator_address !== null) {
+      message.validatorAddress = object.validator_address;
+    }
+    return message;
+  },
+  toAmino(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorAmino {
+    const obj: any = {};
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+    return obj;
+  },
+  fromAminoMsg(object: MsgUnregisterVolunteerValidatorAminoMsg): MsgUnregisterVolunteerValidator {
+    return MsgUnregisterVolunteerValidator.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorAminoMsg {
+    return {
+      type: "xpladev/MsgUnregisterVolunteerValidator",
+      value: MsgUnregisterVolunteerValidator.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgUnregisterVolunteerValidatorProtoMsg): MsgUnregisterVolunteerValidator {
+    return MsgUnregisterVolunteerValidator.decode(message.value);
+  },
+  toProto(message: MsgUnregisterVolunteerValidator): Uint8Array {
+    return MsgUnregisterVolunteerValidator.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator",
+      value: MsgUnregisterVolunteerValidator.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgUnregisterVolunteerValidator.typeUrl, MsgUnregisterVolunteerValidator);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUnregisterVolunteerValidator.aminoType, MsgUnregisterVolunteerValidator.typeUrl);
+function createBaseMsgUnregisterVolunteerValidatorResponse(): MsgUnregisterVolunteerValidatorResponse {
+  return {};
+}
+export const MsgUnregisterVolunteerValidatorResponse = {
+  typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse",
+  is(o: any): o is MsgUnregisterVolunteerValidatorResponse {
+    return o && o.$typeUrl === MsgUnregisterVolunteerValidatorResponse.typeUrl;
+  },
+  isAmino(o: any): o is MsgUnregisterVolunteerValidatorResponseAmino {
+    return o && o.$typeUrl === MsgUnregisterVolunteerValidatorResponse.typeUrl;
+  },
+  encode(_: MsgUnregisterVolunteerValidatorResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUnregisterVolunteerValidatorResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnregisterVolunteerValidatorResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<MsgUnregisterVolunteerValidatorResponse>): MsgUnregisterVolunteerValidatorResponse {
+    const message = createBaseMsgUnregisterVolunteerValidatorResponse();
+    return message;
+  },
+  fromAmino(_: MsgUnregisterVolunteerValidatorResponseAmino): MsgUnregisterVolunteerValidatorResponse {
+    const message = createBaseMsgUnregisterVolunteerValidatorResponse();
+    return message;
+  },
+  toAmino(_: MsgUnregisterVolunteerValidatorResponse): MsgUnregisterVolunteerValidatorResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgUnregisterVolunteerValidatorResponseAminoMsg): MsgUnregisterVolunteerValidatorResponse {
+    return MsgUnregisterVolunteerValidatorResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: MsgUnregisterVolunteerValidatorResponseProtoMsg): MsgUnregisterVolunteerValidatorResponse {
+    return MsgUnregisterVolunteerValidatorResponse.decode(message.value);
+  },
+  toProto(message: MsgUnregisterVolunteerValidatorResponse): Uint8Array {
+    return MsgUnregisterVolunteerValidatorResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUnregisterVolunteerValidatorResponse): MsgUnregisterVolunteerValidatorResponseProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse",
+      value: MsgUnregisterVolunteerValidatorResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgUnregisterVolunteerValidatorResponse.typeUrl, MsgUnregisterVolunteerValidatorResponse);