@xpla/xpla-react 1.8.1 → 1.9.0-rc0

package/dist/cosmos/staking/v1beta1/authz.d.ts

@@ -0,0 +1,156 @@
+import { BinaryReader, BinaryWriter } from "../../../binary.js";
+import { DeepPartial } from "../../../helpers.js";
+import { Coin, CoinAmino } from "../../base/v1beta1/coin.js";
+
+//#region src/cosmos/staking/v1beta1/authz.d.ts
+/** AuthorizationType defines the type of staking module authorization type */
+declare enum AuthorizationType {
+  /** AUTHORIZATION_TYPE_UNSPECIFIED - AUTHORIZATION_TYPE_UNSPECIFIED specifies an unknown authorization type */
+  AUTHORIZATION_TYPE_UNSPECIFIED = 0,
+  /** AUTHORIZATION_TYPE_DELEGATE - AUTHORIZATION_TYPE_DELEGATE defines an authorization type for Msg/Delegate */
+  AUTHORIZATION_TYPE_DELEGATE = 1,
+  /** AUTHORIZATION_TYPE_UNDELEGATE - AUTHORIZATION_TYPE_UNDELEGATE defines an authorization type for Msg/Undelegate */
+  AUTHORIZATION_TYPE_UNDELEGATE = 2,
+  /** AUTHORIZATION_TYPE_REDELEGATE - AUTHORIZATION_TYPE_REDELEGATE defines an authorization type for Msg/BeginRedelegate */
+  AUTHORIZATION_TYPE_REDELEGATE = 3,
+  /** AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION - AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION defines an authorization type for Msg/MsgCancelUnbondingDelegation */
+  AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION = 4,
+  UNRECOGNIZED = -1
+}
+declare const AuthorizationTypeAmino: typeof AuthorizationType;
+declare function authorizationTypeFromJSON(object: any): AuthorizationType;
+declare function authorizationTypeToJSON(object: AuthorizationType): string;
+/**
+ * StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+ * @name StakeAuthorization
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.StakeAuthorization
+ */
+interface StakeAuthorization {
+  /**
+   * max_tokens specifies the maximum amount of tokens can be delegate to a validator. If it is
+   * empty, there is no spend limit and any amount of coins can be delegated.
+   */
+  maxTokens?: Coin;
+  /**
+   * allow_list specifies list of validator addresses to whom grantee can delegate tokens on behalf of granter's
+   * account.
+   */
+  allowList?: StakeAuthorization_Validators;
+  /**
+   * deny_list specifies list of validator addresses to whom grantee can not delegate tokens.
+   */
+  denyList?: StakeAuthorization_Validators;
+  /**
+   * authorization_type defines one of AuthorizationType.
+   */
+  authorizationType: AuthorizationType;
+}
+interface StakeAuthorizationProtoMsg {
+  typeUrl: "/cosmos.staking.v1beta1.StakeAuthorization";
+  value: Uint8Array;
+}
+/**
+ * StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+ * @name StakeAuthorizationAmino
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.StakeAuthorization
+ */
+interface StakeAuthorizationAmino {
+  /**
+   * max_tokens specifies the maximum amount of tokens can be delegate to a validator. If it is
+   * empty, there is no spend limit and any amount of coins can be delegated.
+   */
+  max_tokens?: CoinAmino;
+  /**
+   * allow_list specifies list of validator addresses to whom grantee can delegate tokens on behalf of granter's
+   * account.
+   */
+  allow_list?: StakeAuthorization_ValidatorsAmino;
+  /**
+   * deny_list specifies list of validator addresses to whom grantee can not delegate tokens.
+   */
+  deny_list?: StakeAuthorization_ValidatorsAmino;
+  /**
+   * authorization_type defines one of AuthorizationType.
+   */
+  authorization_type: AuthorizationType;
+}
+interface StakeAuthorizationAminoMsg {
+  type: "cosmos-sdk/StakeAuthorization";
+  value: StakeAuthorizationAmino;
+}
+/**
+ * Validators defines list of validator addresses.
+ * @name StakeAuthorization_Validators
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.Validators
+ */
+interface StakeAuthorization_Validators {
+  address: string[];
+}
+interface StakeAuthorization_ValidatorsProtoMsg {
+  typeUrl: "/cosmos.staking.v1beta1.Validators";
+  value: Uint8Array;
+}
+/**
+ * Validators defines list of validator addresses.
+ * @name StakeAuthorization_ValidatorsAmino
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.StakeAuthorization_Validators
+ */
+interface StakeAuthorization_ValidatorsAmino {
+  address: string[];
+}
+interface StakeAuthorization_ValidatorsAminoMsg {
+  type: "cosmos-sdk/Validators";
+  value: StakeAuthorization_ValidatorsAmino;
+}
+/**
+ * StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+ * @name StakeAuthorization
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.StakeAuthorization
+ */
+declare const StakeAuthorization: {
+  typeUrl: string;
+  aminoType: string;
+  is(o: any): o is StakeAuthorization;
+  isAmino(o: any): o is StakeAuthorizationAmino;
+  encode(message: StakeAuthorization, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): StakeAuthorization;
+  fromPartial(object: DeepPartial<StakeAuthorization>): StakeAuthorization;
+  fromAmino(object: StakeAuthorizationAmino): StakeAuthorization;
+  toAmino(message: StakeAuthorization): StakeAuthorizationAmino;
+  fromAminoMsg(object: StakeAuthorizationAminoMsg): StakeAuthorization;
+  toAminoMsg(message: StakeAuthorization): StakeAuthorizationAminoMsg;
+  fromProtoMsg(message: StakeAuthorizationProtoMsg): StakeAuthorization;
+  toProto(message: StakeAuthorization): Uint8Array;
+  toProtoMsg(message: StakeAuthorization): StakeAuthorizationProtoMsg;
+  registerTypeUrl(): void;
+};
+/**
+ * Validators defines list of validator addresses.
+ * @name StakeAuthorization_Validators
+ * @package cosmos.staking.v1beta1
+ * @see proto type: cosmos.staking.v1beta1.Validators
+ */
+declare const StakeAuthorization_Validators: {
+  typeUrl: string;
+  aminoType: string;
+  is(o: any): o is StakeAuthorization_Validators;
+  isAmino(o: any): o is StakeAuthorization_ValidatorsAmino;
+  encode(message: StakeAuthorization_Validators, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): StakeAuthorization_Validators;
+  fromPartial(object: DeepPartial<StakeAuthorization_Validators>): StakeAuthorization_Validators;
+  fromAmino(object: StakeAuthorization_ValidatorsAmino): StakeAuthorization_Validators;
+  toAmino(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsAmino;
+  fromAminoMsg(object: StakeAuthorization_ValidatorsAminoMsg): StakeAuthorization_Validators;
+  toAminoMsg(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsAminoMsg;
+  fromProtoMsg(message: StakeAuthorization_ValidatorsProtoMsg): StakeAuthorization_Validators;
+  toProto(message: StakeAuthorization_Validators): Uint8Array;
+  toProtoMsg(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsProtoMsg;
+  registerTypeUrl(): void;
+};
+//#endregion
+export { AuthorizationType, AuthorizationTypeAmino, StakeAuthorization, StakeAuthorizationAmino, StakeAuthorizationAminoMsg, StakeAuthorizationProtoMsg, StakeAuthorization_Validators, StakeAuthorization_ValidatorsAmino, StakeAuthorization_ValidatorsAminoMsg, StakeAuthorization_ValidatorsProtoMsg, authorizationTypeFromJSON, authorizationTypeToJSON };

package/dist/cosmos/staking/v1beta1/authz.js

@@ -0,0 +1,238 @@
+import { BinaryReader, BinaryWriter } from "../../../binary.js";
+import { isSet } from "../../../helpers.js";
+import { GlobalDecoderRegistry } from "../../../registry.js";
+import { Coin } from "../../base/v1beta1/coin.js";
+
+//#region src/cosmos/staking/v1beta1/authz.ts
+/** AuthorizationType defines the type of staking module authorization type */
+let AuthorizationType = /* @__PURE__ */ function(AuthorizationType) {
+	/** AUTHORIZATION_TYPE_UNSPECIFIED - AUTHORIZATION_TYPE_UNSPECIFIED specifies an unknown authorization type */
+	AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNSPECIFIED"] = 0] = "AUTHORIZATION_TYPE_UNSPECIFIED";
+	/** AUTHORIZATION_TYPE_DELEGATE - AUTHORIZATION_TYPE_DELEGATE defines an authorization type for Msg/Delegate */
+	AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_DELEGATE"] = 1] = "AUTHORIZATION_TYPE_DELEGATE";
+	/** AUTHORIZATION_TYPE_UNDELEGATE - AUTHORIZATION_TYPE_UNDELEGATE defines an authorization type for Msg/Undelegate */
+	AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNDELEGATE"] = 2] = "AUTHORIZATION_TYPE_UNDELEGATE";
+	/** AUTHORIZATION_TYPE_REDELEGATE - AUTHORIZATION_TYPE_REDELEGATE defines an authorization type for Msg/BeginRedelegate */
+	AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_REDELEGATE"] = 3] = "AUTHORIZATION_TYPE_REDELEGATE";
+	/** AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION - AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION defines an authorization type for Msg/MsgCancelUnbondingDelegation */
+	AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION"] = 4] = "AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION";
+	AuthorizationType[AuthorizationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizationType;
+}({});
+const AuthorizationTypeAmino = AuthorizationType;
+function authorizationTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZATION_TYPE_UNSPECIFIED": return AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED;
+		case 1:
+		case "AUTHORIZATION_TYPE_DELEGATE": return AuthorizationType.AUTHORIZATION_TYPE_DELEGATE;
+		case 2:
+		case "AUTHORIZATION_TYPE_UNDELEGATE": return AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE;
+		case 3:
+		case "AUTHORIZATION_TYPE_REDELEGATE": return AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE;
+		case 4:
+		case "AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION": return AuthorizationType.AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION;
+		default: return AuthorizationType.UNRECOGNIZED;
+	}
+}
+function authorizationTypeToJSON(object) {
+	switch (object) {
+		case AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED: return "AUTHORIZATION_TYPE_UNSPECIFIED";
+		case AuthorizationType.AUTHORIZATION_TYPE_DELEGATE: return "AUTHORIZATION_TYPE_DELEGATE";
+		case AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE: return "AUTHORIZATION_TYPE_UNDELEGATE";
+		case AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE: return "AUTHORIZATION_TYPE_REDELEGATE";
+		case AuthorizationType.AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION: return "AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION";
+		case AuthorizationType.UNRECOGNIZED:
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseStakeAuthorization() {
+	return {
+		maxTokens: void 0,
+		allowList: void 0,
+		denyList: void 0,
+		authorizationType: 0
+	};
+}
+/**
+* StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+* @name StakeAuthorization
+* @package cosmos.staking.v1beta1
+* @see proto type: cosmos.staking.v1beta1.StakeAuthorization
+*/
+const StakeAuthorization = {
+	typeUrl: "/cosmos.staking.v1beta1.StakeAuthorization",
+	aminoType: "cosmos-sdk/StakeAuthorization",
+	is(o) {
+		return o && (o.$typeUrl === StakeAuthorization.typeUrl || isSet(o.authorizationType));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === StakeAuthorization.typeUrl || isSet(o.authorization_type));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.maxTokens !== void 0) Coin.encode(message.maxTokens, writer.uint32(10).fork()).ldelim();
+		if (message.allowList !== void 0) StakeAuthorization_Validators.encode(message.allowList, writer.uint32(18).fork()).ldelim();
+		if (message.denyList !== void 0) StakeAuthorization_Validators.encode(message.denyList, writer.uint32(26).fork()).ldelim();
+		if (message.authorizationType !== 0) writer.uint32(32).int32(message.authorizationType);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseStakeAuthorization();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.maxTokens = Coin.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.allowList = StakeAuthorization_Validators.decode(reader, reader.uint32());
+					break;
+				case 3:
+					message.denyList = StakeAuthorization_Validators.decode(reader, reader.uint32());
+					break;
+				case 4:
+					message.authorizationType = reader.int32();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseStakeAuthorization();
+		message.maxTokens = object.maxTokens !== void 0 && object.maxTokens !== null ? Coin.fromPartial(object.maxTokens) : void 0;
+		message.allowList = object.allowList !== void 0 && object.allowList !== null ? StakeAuthorization_Validators.fromPartial(object.allowList) : void 0;
+		message.denyList = object.denyList !== void 0 && object.denyList !== null ? StakeAuthorization_Validators.fromPartial(object.denyList) : void 0;
+		message.authorizationType = object.authorizationType ?? 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseStakeAuthorization();
+		if (object.max_tokens !== void 0 && object.max_tokens !== null) message.maxTokens = Coin.fromAmino(object.max_tokens);
+		if (object.allow_list !== void 0 && object.allow_list !== null) message.allowList = StakeAuthorization_Validators.fromAmino(object.allow_list);
+		if (object.deny_list !== void 0 && object.deny_list !== null) message.denyList = StakeAuthorization_Validators.fromAmino(object.deny_list);
+		if (object.authorization_type !== void 0 && object.authorization_type !== null) message.authorizationType = object.authorization_type;
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.max_tokens = message.maxTokens ? Coin.toAmino(message.maxTokens) : void 0;
+		obj.allow_list = message.allowList ? StakeAuthorization_Validators.toAmino(message.allowList) : void 0;
+		obj.deny_list = message.denyList ? StakeAuthorization_Validators.toAmino(message.denyList) : void 0;
+		obj.authorization_type = message.authorizationType === 0 ? void 0 : message.authorizationType;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return StakeAuthorization.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/StakeAuthorization",
+			value: StakeAuthorization.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return StakeAuthorization.decode(message.value);
+	},
+	toProto(message) {
+		return StakeAuthorization.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.staking.v1beta1.StakeAuthorization",
+			value: StakeAuthorization.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(StakeAuthorization.typeUrl)) return;
+		GlobalDecoderRegistry.register(StakeAuthorization.typeUrl, StakeAuthorization);
+		GlobalDecoderRegistry.registerAminoProtoMapping(StakeAuthorization.aminoType, StakeAuthorization.typeUrl);
+		Coin.registerTypeUrl();
+		StakeAuthorization_Validators.registerTypeUrl();
+	}
+};
+function createBaseStakeAuthorization_Validators() {
+	return { address: [] };
+}
+/**
+* Validators defines list of validator addresses.
+* @name StakeAuthorization_Validators
+* @package cosmos.staking.v1beta1
+* @see proto type: cosmos.staking.v1beta1.Validators
+*/
+const StakeAuthorization_Validators = {
+	typeUrl: "/cosmos.staking.v1beta1.Validators",
+	aminoType: "cosmos-sdk/Validators",
+	is(o) {
+		return o && (o.$typeUrl === StakeAuthorization_Validators.typeUrl || Array.isArray(o.address) && (!o.address.length || typeof o.address[0] === "string"));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === StakeAuthorization_Validators.typeUrl || Array.isArray(o.address) && (!o.address.length || typeof o.address[0] === "string"));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		for (const v of message.address) writer.uint32(10).string(v);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseStakeAuthorization_Validators();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.address.push(reader.string());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseStakeAuthorization_Validators();
+		message.address = object.address?.map((e) => e) || [];
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseStakeAuthorization_Validators();
+		message.address = object.address?.map((e) => e) || [];
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		if (message.address) obj.address = message.address.map((e) => e);
+		else obj.address = message.address;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return StakeAuthorization_Validators.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/Validators",
+			value: StakeAuthorization_Validators.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return StakeAuthorization_Validators.decode(message.value);
+	},
+	toProto(message) {
+		return StakeAuthorization_Validators.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.staking.v1beta1.Validators",
+			value: StakeAuthorization_Validators.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {}
+};
+
+//#endregion
+export { AuthorizationType, AuthorizationTypeAmino, StakeAuthorization, StakeAuthorization_Validators, authorizationTypeFromJSON, authorizationTypeToJSON };

package/dist/cosmos/staking/v1beta1/genesis.cjs

@@ -0,0 +1,247 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_binary = require('../../../binary.cjs');
+require('../../../helpers.cjs');
+const require_registry = require('../../../registry.cjs');
+const require_cosmos_staking_v1beta1_staking = require('./staking.cjs');
+let _interchainjs_encoding = require("@interchainjs/encoding");
+
+//#region src/cosmos/staking/v1beta1/genesis.ts
+function createBaseGenesisState() {
+	return {
+		params: require_cosmos_staking_v1beta1_staking.Params.fromPartial({}),
+		lastTotalPower: new Uint8Array(),
+		lastValidatorPowers: [],
+		validators: [],
+		delegations: [],
+		unbondingDelegations: [],
+		redelegations: [],
+		exported: false
+	};
+}
+/**
+* GenesisState defines the staking module's genesis state.
+* @name GenesisState
+* @package cosmos.staking.v1beta1
+* @see proto type: cosmos.staking.v1beta1.GenesisState
+*/
+const GenesisState = {
+	typeUrl: "/cosmos.staking.v1beta1.GenesisState",
+	aminoType: "cosmos-sdk/GenesisState",
+	is(o) {
+		return o && (o.$typeUrl === GenesisState.typeUrl || require_cosmos_staking_v1beta1_staking.Params.is(o.params) && (o.lastTotalPower instanceof Uint8Array || typeof o.lastTotalPower === "string") && Array.isArray(o.lastValidatorPowers) && (!o.lastValidatorPowers.length || LastValidatorPower.is(o.lastValidatorPowers[0])) && Array.isArray(o.validators) && (!o.validators.length || require_cosmos_staking_v1beta1_staking.Validator.is(o.validators[0])) && Array.isArray(o.delegations) && (!o.delegations.length || require_cosmos_staking_v1beta1_staking.Delegation.is(o.delegations[0])) && Array.isArray(o.unbondingDelegations) && (!o.unbondingDelegations.length || require_cosmos_staking_v1beta1_staking.UnbondingDelegation.is(o.unbondingDelegations[0])) && Array.isArray(o.redelegations) && (!o.redelegations.length || require_cosmos_staking_v1beta1_staking.Redelegation.is(o.redelegations[0])) && typeof o.exported === "boolean");
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === GenesisState.typeUrl || require_cosmos_staking_v1beta1_staking.Params.isAmino(o.params) && (o.last_total_power instanceof Uint8Array || typeof o.last_total_power === "string") && Array.isArray(o.last_validator_powers) && (!o.last_validator_powers.length || LastValidatorPower.isAmino(o.last_validator_powers[0])) && Array.isArray(o.validators) && (!o.validators.length || require_cosmos_staking_v1beta1_staking.Validator.isAmino(o.validators[0])) && Array.isArray(o.delegations) && (!o.delegations.length || require_cosmos_staking_v1beta1_staking.Delegation.isAmino(o.delegations[0])) && Array.isArray(o.unbonding_delegations) && (!o.unbonding_delegations.length || require_cosmos_staking_v1beta1_staking.UnbondingDelegation.isAmino(o.unbonding_delegations[0])) && Array.isArray(o.redelegations) && (!o.redelegations.length || require_cosmos_staking_v1beta1_staking.Redelegation.isAmino(o.redelegations[0])) && typeof o.exported === "boolean");
+	},
+	encode(message, writer = require_binary.BinaryWriter.create()) {
+		if (message.params !== void 0) require_cosmos_staking_v1beta1_staking.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+		if (message.lastTotalPower.length !== 0) writer.uint32(18).bytes(message.lastTotalPower);
+		for (const v of message.lastValidatorPowers) LastValidatorPower.encode(v, writer.uint32(26).fork()).ldelim();
+		for (const v of message.validators) require_cosmos_staking_v1beta1_staking.Validator.encode(v, writer.uint32(34).fork()).ldelim();
+		for (const v of message.delegations) require_cosmos_staking_v1beta1_staking.Delegation.encode(v, writer.uint32(42).fork()).ldelim();
+		for (const v of message.unbondingDelegations) require_cosmos_staking_v1beta1_staking.UnbondingDelegation.encode(v, writer.uint32(50).fork()).ldelim();
+		for (const v of message.redelegations) require_cosmos_staking_v1beta1_staking.Redelegation.encode(v, writer.uint32(58).fork()).ldelim();
+		if (message.exported === true) writer.uint32(64).bool(message.exported);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof require_binary.BinaryReader ? input : new require_binary.BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseGenesisState();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.params = require_cosmos_staking_v1beta1_staking.Params.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.lastTotalPower = reader.bytes();
+					break;
+				case 3:
+					message.lastValidatorPowers.push(LastValidatorPower.decode(reader, reader.uint32()));
+					break;
+				case 4:
+					message.validators.push(require_cosmos_staking_v1beta1_staking.Validator.decode(reader, reader.uint32()));
+					break;
+				case 5:
+					message.delegations.push(require_cosmos_staking_v1beta1_staking.Delegation.decode(reader, reader.uint32()));
+					break;
+				case 6:
+					message.unbondingDelegations.push(require_cosmos_staking_v1beta1_staking.UnbondingDelegation.decode(reader, reader.uint32()));
+					break;
+				case 7:
+					message.redelegations.push(require_cosmos_staking_v1beta1_staking.Redelegation.decode(reader, reader.uint32()));
+					break;
+				case 8:
+					message.exported = reader.bool();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseGenesisState();
+		message.params = object.params !== void 0 && object.params !== null ? require_cosmos_staking_v1beta1_staking.Params.fromPartial(object.params) : void 0;
+		message.lastTotalPower = object.lastTotalPower ?? new Uint8Array();
+		message.lastValidatorPowers = object.lastValidatorPowers?.map((e) => LastValidatorPower.fromPartial(e)) || [];
+		message.validators = object.validators?.map((e) => require_cosmos_staking_v1beta1_staking.Validator.fromPartial(e)) || [];
+		message.delegations = object.delegations?.map((e) => require_cosmos_staking_v1beta1_staking.Delegation.fromPartial(e)) || [];
+		message.unbondingDelegations = object.unbondingDelegations?.map((e) => require_cosmos_staking_v1beta1_staking.UnbondingDelegation.fromPartial(e)) || [];
+		message.redelegations = object.redelegations?.map((e) => require_cosmos_staking_v1beta1_staking.Redelegation.fromPartial(e)) || [];
+		message.exported = object.exported ?? false;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseGenesisState();
+		if (object.params !== void 0 && object.params !== null) message.params = require_cosmos_staking_v1beta1_staking.Params.fromAmino(object.params);
+		if (object.last_total_power !== void 0 && object.last_total_power !== null) message.lastTotalPower = (0, _interchainjs_encoding.fromBase64)(object.last_total_power);
+		message.lastValidatorPowers = object.last_validator_powers?.map((e) => LastValidatorPower.fromAmino(e)) || [];
+		message.validators = object.validators?.map((e) => require_cosmos_staking_v1beta1_staking.Validator.fromAmino(e)) || [];
+		message.delegations = object.delegations?.map((e) => require_cosmos_staking_v1beta1_staking.Delegation.fromAmino(e)) || [];
+		message.unbondingDelegations = object.unbonding_delegations?.map((e) => require_cosmos_staking_v1beta1_staking.UnbondingDelegation.fromAmino(e)) || [];
+		message.redelegations = object.redelegations?.map((e) => require_cosmos_staking_v1beta1_staking.Redelegation.fromAmino(e)) || [];
+		if (object.exported !== void 0 && object.exported !== null) message.exported = object.exported;
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.params = message.params ? require_cosmos_staking_v1beta1_staking.Params.toAmino(message.params) : require_cosmos_staking_v1beta1_staking.Params.toAmino(require_cosmos_staking_v1beta1_staking.Params.fromPartial({}));
+		obj.last_total_power = message.lastTotalPower ? (0, _interchainjs_encoding.toBase64)(message.lastTotalPower) : "";
+		if (message.lastValidatorPowers) obj.last_validator_powers = message.lastValidatorPowers.map((e) => e ? LastValidatorPower.toAmino(e) : void 0);
+		else obj.last_validator_powers = message.lastValidatorPowers;
+		if (message.validators) obj.validators = message.validators.map((e) => e ? require_cosmos_staking_v1beta1_staking.Validator.toAmino(e) : void 0);
+		else obj.validators = message.validators;
+		if (message.delegations) obj.delegations = message.delegations.map((e) => e ? require_cosmos_staking_v1beta1_staking.Delegation.toAmino(e) : void 0);
+		else obj.delegations = message.delegations;
+		if (message.unbondingDelegations) obj.unbonding_delegations = message.unbondingDelegations.map((e) => e ? require_cosmos_staking_v1beta1_staking.UnbondingDelegation.toAmino(e) : void 0);
+		else obj.unbonding_delegations = message.unbondingDelegations;
+		if (message.redelegations) obj.redelegations = message.redelegations.map((e) => e ? require_cosmos_staking_v1beta1_staking.Redelegation.toAmino(e) : void 0);
+		else obj.redelegations = message.redelegations;
+		obj.exported = message.exported === false ? void 0 : message.exported;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return GenesisState.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/GenesisState",
+			value: GenesisState.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return GenesisState.decode(message.value);
+	},
+	toProto(message) {
+		return GenesisState.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.staking.v1beta1.GenesisState",
+			value: GenesisState.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!require_registry.GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) return;
+		require_cosmos_staking_v1beta1_staking.Params.registerTypeUrl();
+		LastValidatorPower.registerTypeUrl();
+		require_cosmos_staking_v1beta1_staking.Validator.registerTypeUrl();
+		require_cosmos_staking_v1beta1_staking.Delegation.registerTypeUrl();
+		require_cosmos_staking_v1beta1_staking.UnbondingDelegation.registerTypeUrl();
+		require_cosmos_staking_v1beta1_staking.Redelegation.registerTypeUrl();
+	}
+};
+function createBaseLastValidatorPower() {
+	return {
+		address: "",
+		power: BigInt(0)
+	};
+}
+/**
+* LastValidatorPower required for validator set update logic.
+* @name LastValidatorPower
+* @package cosmos.staking.v1beta1
+* @see proto type: cosmos.staking.v1beta1.LastValidatorPower
+*/
+const LastValidatorPower = {
+	typeUrl: "/cosmos.staking.v1beta1.LastValidatorPower",
+	aminoType: "cosmos-sdk/LastValidatorPower",
+	is(o) {
+		return o && (o.$typeUrl === LastValidatorPower.typeUrl || typeof o.address === "string" && typeof o.power === "bigint");
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === LastValidatorPower.typeUrl || typeof o.address === "string" && typeof o.power === "bigint");
+	},
+	encode(message, writer = require_binary.BinaryWriter.create()) {
+		if (message.address !== "") writer.uint32(10).string(message.address);
+		if (message.power !== BigInt(0)) writer.uint32(16).int64(message.power);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof require_binary.BinaryReader ? input : new require_binary.BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseLastValidatorPower();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.address = reader.string();
+					break;
+				case 2:
+					message.power = reader.int64();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseLastValidatorPower();
+		message.address = object.address ?? "";
+		message.power = object.power !== void 0 && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseLastValidatorPower();
+		if (object.address !== void 0 && object.address !== null) message.address = object.address;
+		if (object.power !== void 0 && object.power !== null) message.power = BigInt(object.power);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.address = message.address === "" ? void 0 : message.address;
+		obj.power = message.power !== BigInt(0) ? message.power?.toString() : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return LastValidatorPower.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/LastValidatorPower",
+			value: LastValidatorPower.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return LastValidatorPower.decode(message.value);
+	},
+	toProto(message) {
+		return LastValidatorPower.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.staking.v1beta1.LastValidatorPower",
+			value: LastValidatorPower.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {}
+};
+
+//#endregion
+exports.GenesisState = GenesisState;
+exports.LastValidatorPower = LastValidatorPower;