@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.11

package/cosmos/staking/v1beta1/authz.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakeAuthorization_Validators = exports.StakeAuthorization = exports.authorizationTypeToJSON = exports.authorizationTypeFromJSON = exports.AuthorizationTypeAmino = exports.AuthorizationType = void 0;
+const coin_1 = require("../../base/v1beta1/coin");
+const helpers_1 = require("../../../helpers");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+/**
+ * AuthorizationType defines the type of staking module authorization type
+ *
+ * Since: cosmos-sdk 0.43
+ */
+var AuthorizationType;
+(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";
+})(AuthorizationType = exports.AuthorizationType || (exports.AuthorizationType = {}));
+exports.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;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return AuthorizationType.UNRECOGNIZED;
+    }
+}
+exports.authorizationTypeFromJSON = authorizationTypeFromJSON;
+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";
+    }
+}
+exports.authorizationTypeToJSON = authorizationTypeToJSON;
+function createBaseStakeAuthorization() {
+    return {
+        maxTokens: undefined,
+        allowList: undefined,
+        denyList: undefined,
+        authorizationType: 0
+    };
+}
+exports.StakeAuthorization = {
+    typeUrl: "/cosmos.staking.v1beta1.StakeAuthorization",
+    aminoType: "cosmos-sdk/StakeAuthorization",
+    is(o) {
+        return o && (o.$typeUrl === exports.StakeAuthorization.typeUrl || (0, helpers_1.isSet)(o.authorizationType));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.StakeAuthorization.typeUrl || (0, helpers_1.isSet)(o.authorization_type));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.maxTokens !== undefined) {
+            coin_1.Coin.encode(message.maxTokens, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.allowList !== undefined) {
+            exports.StakeAuthorization_Validators.encode(message.allowList, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.denyList !== undefined) {
+            exports.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStakeAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.maxTokens = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.allowList = exports.StakeAuthorization_Validators.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.denyList = exports.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 !== undefined && object.maxTokens !== null ? coin_1.Coin.fromPartial(object.maxTokens) : undefined;
+        message.allowList = object.allowList !== undefined && object.allowList !== null ? exports.StakeAuthorization_Validators.fromPartial(object.allowList) : undefined;
+        message.denyList = object.denyList !== undefined && object.denyList !== null ? exports.StakeAuthorization_Validators.fromPartial(object.denyList) : undefined;
+        message.authorizationType = object.authorizationType ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseStakeAuthorization();
+        if (object.max_tokens !== undefined && object.max_tokens !== null) {
+            message.maxTokens = coin_1.Coin.fromAmino(object.max_tokens);
+        }
+        if (object.allow_list !== undefined && object.allow_list !== null) {
+            message.allowList = exports.StakeAuthorization_Validators.fromAmino(object.allow_list);
+        }
+        if (object.deny_list !== undefined && object.deny_list !== null) {
+            message.denyList = exports.StakeAuthorization_Validators.fromAmino(object.deny_list);
+        }
+        if (object.authorization_type !== undefined && object.authorization_type !== null) {
+            message.authorizationType = object.authorization_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.max_tokens = message.maxTokens ? coin_1.Coin.toAmino(message.maxTokens) : undefined;
+        obj.allow_list = message.allowList ? exports.StakeAuthorization_Validators.toAmino(message.allowList) : undefined;
+        obj.deny_list = message.denyList ? exports.StakeAuthorization_Validators.toAmino(message.denyList) : undefined;
+        obj.authorization_type = message.authorizationType === 0 ? undefined : message.authorizationType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.StakeAuthorization.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/StakeAuthorization",
+            value: exports.StakeAuthorization.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.StakeAuthorization.decode(message.value);
+    },
+    toProto(message) {
+        return exports.StakeAuthorization.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.staking.v1beta1.StakeAuthorization",
+            value: exports.StakeAuthorization.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        registry_1.GlobalDecoderRegistry.register(exports.StakeAuthorization.typeUrl, exports.StakeAuthorization);
+        registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.StakeAuthorization.aminoType, exports.StakeAuthorization.typeUrl);
+        coin_1.Coin.registerTypeUrl();
+        exports.StakeAuthorization_Validators.registerTypeUrl();
+    }
+};
+function createBaseStakeAuthorization_Validators() {
+    return {
+        address: []
+    };
+}
+exports.StakeAuthorization_Validators = {
+    typeUrl: "/cosmos.staking.v1beta1.Validators",
+    aminoType: "cosmos-sdk/Validators",
+    is(o) {
+        return o && (o.$typeUrl === exports.StakeAuthorization_Validators.typeUrl || Array.isArray(o.address) && (!o.address.length || typeof o.address[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.StakeAuthorization_Validators.typeUrl || Array.isArray(o.address) && (!o.address.length || typeof o.address[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.address) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? 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 exports.StakeAuthorization_Validators.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Validators",
+            value: exports.StakeAuthorization_Validators.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.StakeAuthorization_Validators.decode(message.value);
+    },
+    toProto(message) {
+        return exports.StakeAuthorization_Validators.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.staking.v1beta1.Validators",
+            value: exports.StakeAuthorization_Validators.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/cosmos/staking/v1beta1/genesis.d.ts

@@ -0,0 +1,117 @@
+import { Params, ParamsAmino, Validator, ValidatorAmino, Delegation, DelegationAmino, UnbondingDelegation, UnbondingDelegationAmino, Redelegation, RedelegationAmino } from "./staking";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the staking module's genesis state. */
+export interface GenesisState {
+    /** params defines all the parameters of related to deposit. */
+    params: Params;
+    /**
+     * last_total_power tracks the total amounts of bonded tokens recorded during
+     * the previous end block.
+     */
+    lastTotalPower: Uint8Array;
+    /**
+     * last_validator_powers is a special index that provides a historical list
+     * of the last-block's bonded validators.
+     */
+    lastValidatorPowers: LastValidatorPower[];
+    /** validators defines the validator set at genesis. */
+    validators: Validator[];
+    /** delegations defines the delegations active at genesis. */
+    delegations: Delegation[];
+    /** unbonding_delegations defines the unbonding delegations active at genesis. */
+    unbondingDelegations: UnbondingDelegation[];
+    /** redelegations defines the redelegations active at genesis. */
+    redelegations: Redelegation[];
+    /** exported defines a bool to identify whether the chain dealing with exported or initialized genesis. */
+    exported: boolean;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/cosmos.staking.v1beta1.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the staking module's genesis state. */
+export interface GenesisStateAmino {
+    /** params defines all the parameters of related to deposit. */
+    params: ParamsAmino;
+    /**
+     * last_total_power tracks the total amounts of bonded tokens recorded during
+     * the previous end block.
+     */
+    last_total_power: string;
+    /**
+     * last_validator_powers is a special index that provides a historical list
+     * of the last-block's bonded validators.
+     */
+    last_validator_powers: LastValidatorPowerAmino[];
+    /** validators defines the validator set at genesis. */
+    validators: ValidatorAmino[];
+    /** delegations defines the delegations active at genesis. */
+    delegations: DelegationAmino[];
+    /** unbonding_delegations defines the unbonding delegations active at genesis. */
+    unbonding_delegations: UnbondingDelegationAmino[];
+    /** redelegations defines the redelegations active at genesis. */
+    redelegations: RedelegationAmino[];
+    /** exported defines a bool to identify whether the chain dealing with exported or initialized genesis. */
+    exported: boolean;
+}
+export interface GenesisStateAminoMsg {
+    type: "cosmos-sdk/GenesisState";
+    value: GenesisStateAmino;
+}
+/** LastValidatorPower required for validator set update logic. */
+export interface LastValidatorPower {
+    /** address is the address of the validator. */
+    address: string;
+    /** power defines the power of the validator. */
+    power: bigint;
+}
+export interface LastValidatorPowerProtoMsg {
+    typeUrl: "/cosmos.staking.v1beta1.LastValidatorPower";
+    value: Uint8Array;
+}
+/** LastValidatorPower required for validator set update logic. */
+export interface LastValidatorPowerAmino {
+    /** address is the address of the validator. */
+    address: string;
+    /** power defines the power of the validator. */
+    power: string;
+}
+export interface LastValidatorPowerAminoMsg {
+    type: "cosmos-sdk/LastValidatorPower";
+    value: LastValidatorPowerAmino;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const LastValidatorPower: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is LastValidatorPower;
+    isAmino(o: any): o is LastValidatorPowerAmino;
+    encode(message: LastValidatorPower, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): LastValidatorPower;
+    fromPartial(object: DeepPartial<LastValidatorPower>): LastValidatorPower;
+    fromAmino(object: LastValidatorPowerAmino): LastValidatorPower;
+    toAmino(message: LastValidatorPower): LastValidatorPowerAmino;
+    fromAminoMsg(object: LastValidatorPowerAminoMsg): LastValidatorPower;
+    toAminoMsg(message: LastValidatorPower): LastValidatorPowerAminoMsg;
+    fromProtoMsg(message: LastValidatorPowerProtoMsg): LastValidatorPower;
+    toProto(message: LastValidatorPower): Uint8Array;
+    toProtoMsg(message: LastValidatorPower): LastValidatorPowerProtoMsg;
+    registerTypeUrl(): void;
+};

package/cosmos/staking/v1beta1/genesis.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastValidatorPower = exports.GenesisState = void 0;
+const staking_1 = require("./staking");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseGenesisState() {
+    return {
+        params: staking_1.Params.fromPartial({}),
+        lastTotalPower: new Uint8Array(),
+        lastValidatorPowers: [],
+        validators: [],
+        delegations: [],
+        unbondingDelegations: [],
+        redelegations: [],
+        exported: false
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/cosmos.staking.v1beta1.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || staking_1.Params.is(o.params) && (o.lastTotalPower instanceof Uint8Array || typeof o.lastTotalPower === "string") && Array.isArray(o.lastValidatorPowers) && (!o.lastValidatorPowers.length || exports.LastValidatorPower.is(o.lastValidatorPowers[0])) && Array.isArray(o.validators) && (!o.validators.length || staking_1.Validator.is(o.validators[0])) && Array.isArray(o.delegations) && (!o.delegations.length || staking_1.Delegation.is(o.delegations[0])) && Array.isArray(o.unbondingDelegations) && (!o.unbondingDelegations.length || staking_1.UnbondingDelegation.is(o.unbondingDelegations[0])) && Array.isArray(o.redelegations) && (!o.redelegations.length || staking_1.Redelegation.is(o.redelegations[0])) && typeof o.exported === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || staking_1.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 || exports.LastValidatorPower.isAmino(o.last_validator_powers[0])) && Array.isArray(o.validators) && (!o.validators.length || staking_1.Validator.isAmino(o.validators[0])) && Array.isArray(o.delegations) && (!o.delegations.length || staking_1.Delegation.isAmino(o.delegations[0])) && Array.isArray(o.unbonding_delegations) && (!o.unbonding_delegations.length || staking_1.UnbondingDelegation.isAmino(o.unbonding_delegations[0])) && Array.isArray(o.redelegations) && (!o.redelegations.length || staking_1.Redelegation.isAmino(o.redelegations[0])) && typeof o.exported === "boolean");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            staking_1.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) {
+            exports.LastValidatorPower.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.validators) {
+            staking_1.Validator.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.delegations) {
+            staking_1.Delegation.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.unbondingDelegations) {
+            staking_1.UnbondingDelegation.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.redelegations) {
+            staking_1.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = staking_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.lastTotalPower = reader.bytes();
+                    break;
+                case 3:
+                    message.lastValidatorPowers.push(exports.LastValidatorPower.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.validators.push(staking_1.Validator.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.delegations.push(staking_1.Delegation.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.unbondingDelegations.push(staking_1.UnbondingDelegation.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.redelegations.push(staking_1.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 !== undefined && object.params !== null ? staking_1.Params.fromPartial(object.params) : undefined;
+        message.lastTotalPower = object.lastTotalPower ?? new Uint8Array();
+        message.lastValidatorPowers = object.lastValidatorPowers?.map(e => exports.LastValidatorPower.fromPartial(e)) || [];
+        message.validators = object.validators?.map(e => staking_1.Validator.fromPartial(e)) || [];
+        message.delegations = object.delegations?.map(e => staking_1.Delegation.fromPartial(e)) || [];
+        message.unbondingDelegations = object.unbondingDelegations?.map(e => staking_1.UnbondingDelegation.fromPartial(e)) || [];
+        message.redelegations = object.redelegations?.map(e => staking_1.Redelegation.fromPartial(e)) || [];
+        message.exported = object.exported ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = staking_1.Params.fromAmino(object.params);
+        }
+        if (object.last_total_power !== undefined && object.last_total_power !== null) {
+            message.lastTotalPower = (0, helpers_1.bytesFromBase64)(object.last_total_power);
+        }
+        message.lastValidatorPowers = object.last_validator_powers?.map(e => exports.LastValidatorPower.fromAmino(e)) || [];
+        message.validators = object.validators?.map(e => staking_1.Validator.fromAmino(e)) || [];
+        message.delegations = object.delegations?.map(e => staking_1.Delegation.fromAmino(e)) || [];
+        message.unbondingDelegations = object.unbonding_delegations?.map(e => staking_1.UnbondingDelegation.fromAmino(e)) || [];
+        message.redelegations = object.redelegations?.map(e => staking_1.Redelegation.fromAmino(e)) || [];
+        if (object.exported !== undefined && object.exported !== null) {
+            message.exported = object.exported;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? staking_1.Params.toAmino(message.params) : staking_1.Params.toAmino(staking_1.Params.fromPartial({}));
+        obj.last_total_power = message.lastTotalPower ? (0, helpers_1.base64FromBytes)(message.lastTotalPower) : "";
+        if (message.lastValidatorPowers) {
+            obj.last_validator_powers = message.lastValidatorPowers.map(e => e ? exports.LastValidatorPower.toAmino(e) : undefined);
+        }
+        else {
+            obj.last_validator_powers = message.lastValidatorPowers;
+        }
+        if (message.validators) {
+            obj.validators = message.validators.map(e => e ? staking_1.Validator.toAmino(e) : undefined);
+        }
+        else {
+            obj.validators = message.validators;
+        }
+        if (message.delegations) {
+            obj.delegations = message.delegations.map(e => e ? staking_1.Delegation.toAmino(e) : undefined);
+        }
+        else {
+            obj.delegations = message.delegations;
+        }
+        if (message.unbondingDelegations) {
+            obj.unbonding_delegations = message.unbondingDelegations.map(e => e ? staking_1.UnbondingDelegation.toAmino(e) : undefined);
+        }
+        else {
+            obj.unbonding_delegations = message.unbondingDelegations;
+        }
+        if (message.redelegations) {
+            obj.redelegations = message.redelegations.map(e => e ? staking_1.Redelegation.toAmino(e) : undefined);
+        }
+        else {
+            obj.redelegations = message.redelegations;
+        }
+        obj.exported = message.exported === false ? undefined : message.exported;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: exports.GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.staking.v1beta1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        staking_1.Params.registerTypeUrl();
+        exports.LastValidatorPower.registerTypeUrl();
+        staking_1.Validator.registerTypeUrl();
+        staking_1.Delegation.registerTypeUrl();
+        staking_1.UnbondingDelegation.registerTypeUrl();
+        staking_1.Redelegation.registerTypeUrl();
+    }
+};
+function createBaseLastValidatorPower() {
+    return {
+        address: "",
+        power: BigInt(0)
+    };
+}
+exports.LastValidatorPower = {
+    typeUrl: "/cosmos.staking.v1beta1.LastValidatorPower",
+    aminoType: "cosmos-sdk/LastValidatorPower",
+    is(o) {
+        return o && (o.$typeUrl === exports.LastValidatorPower.typeUrl || typeof o.address === "string" && typeof o.power === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.LastValidatorPower.typeUrl || typeof o.address === "string" && typeof o.power === "bigint");
+    },
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? 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 !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLastValidatorPower();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.power !== undefined && object.power !== null) {
+            message.power = BigInt(object.power);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.power = message.power !== BigInt(0) ? message.power?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.LastValidatorPower.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/LastValidatorPower",
+            value: exports.LastValidatorPower.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.LastValidatorPower.decode(message.value);
+    },
+    toProto(message) {
+        return exports.LastValidatorPower.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.staking.v1beta1.LastValidatorPower",
+            value: exports.LastValidatorPower.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};