@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/staking/v1beta1/genesis.ts

@@ -0,0 +1,233 @@
+import { Params, ParamsSDKType, Validator, ValidatorSDKType, Delegation, DelegationSDKType, UnbondingDelegation, UnbondingDelegationSDKType, Redelegation, RedelegationSDKType } from "./staking";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } 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;
+}
+/** GenesisState defines the staking module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: ParamsSDKType;
+  last_total_power: Uint8Array;
+  last_validator_powers: LastValidatorPowerSDKType[];
+  validators: ValidatorSDKType[];
+  delegations: DelegationSDKType[];
+  unbonding_delegations: UnbondingDelegationSDKType[];
+  redelegations: RedelegationSDKType[];
+  exported: boolean;
+}
+/** 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: Long;
+}
+/** LastValidatorPower required for validator set update logic. */
+
+export interface LastValidatorPowerSDKType {
+  address: string;
+  power: Long;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    lastTotalPower: new Uint8Array(),
+    lastValidatorPowers: [],
+    validators: [],
+    delegations: [],
+    unbondingDelegations: [],
+    redelegations: [],
+    exported: false
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      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) {
+      Validator.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
+    for (const v of message.delegations) {
+      Delegation.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+
+    for (const v of message.unbondingDelegations) {
+      UnbondingDelegation.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
+    for (const v of message.redelegations) {
+      Redelegation.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
+
+    if (message.exported === true) {
+      writer.uint32(64).bool(message.exported);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 = 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(Validator.decode(reader, reader.uint32()));
+          break;
+
+        case 5:
+          message.delegations.push(Delegation.decode(reader, reader.uint32()));
+          break;
+
+        case 6:
+          message.unbondingDelegations.push(UnbondingDelegation.decode(reader, reader.uint32()));
+          break;
+
+        case 7:
+          message.redelegations.push(Redelegation.decode(reader, reader.uint32()));
+          break;
+
+        case 8:
+          message.exported = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.lastTotalPower = object.lastTotalPower ?? new Uint8Array();
+    message.lastValidatorPowers = object.lastValidatorPowers?.map(e => LastValidatorPower.fromPartial(e)) || [];
+    message.validators = object.validators?.map(e => Validator.fromPartial(e)) || [];
+    message.delegations = object.delegations?.map(e => Delegation.fromPartial(e)) || [];
+    message.unbondingDelegations = object.unbondingDelegations?.map(e => UnbondingDelegation.fromPartial(e)) || [];
+    message.redelegations = object.redelegations?.map(e => Redelegation.fromPartial(e)) || [];
+    message.exported = object.exported ?? false;
+    return message;
+  }
+
+};
+
+function createBaseLastValidatorPower(): LastValidatorPower {
+  return {
+    address: "",
+    power: Long.ZERO
+  };
+}
+
+export const LastValidatorPower = {
+  encode(message: LastValidatorPower, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    if (!message.power.isZero()) {
+      writer.uint32(16).int64(message.power);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LastValidatorPower {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LastValidatorPower>): LastValidatorPower {
+    const message = createBaseLastValidatorPower();
+    message.address = object.address ?? "";
+    message.power = object.power !== undefined && object.power !== null ? Long.fromValue(object.power) : Long.ZERO;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/staking/v1beta1/query.lcd.ts

@@ -0,0 +1,220 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryValidatorsRequest, QueryValidatorsResponseSDKType, QueryValidatorRequest, QueryValidatorResponseSDKType, QueryValidatorDelegationsRequest, QueryValidatorDelegationsResponseSDKType, QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponseSDKType, QueryDelegationRequest, QueryDelegationResponseSDKType, QueryUnbondingDelegationRequest, QueryUnbondingDelegationResponseSDKType, QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsResponseSDKType, QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsResponseSDKType, QueryRedelegationsRequest, QueryRedelegationsResponseSDKType, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponseSDKType, QueryDelegatorValidatorRequest, QueryDelegatorValidatorResponseSDKType, QueryHistoricalInfoRequest, QueryHistoricalInfoResponseSDKType, QueryPoolRequest, QueryPoolResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.validators = this.validators.bind(this);
+    this.validator = this.validator.bind(this);
+    this.validatorDelegations = this.validatorDelegations.bind(this);
+    this.validatorUnbondingDelegations = this.validatorUnbondingDelegations.bind(this);
+    this.delegation = this.delegation.bind(this);
+    this.unbondingDelegation = this.unbondingDelegation.bind(this);
+    this.delegatorDelegations = this.delegatorDelegations.bind(this);
+    this.delegatorUnbondingDelegations = this.delegatorUnbondingDelegations.bind(this);
+    this.redelegations = this.redelegations.bind(this);
+    this.delegatorValidators = this.delegatorValidators.bind(this);
+    this.delegatorValidator = this.delegatorValidator.bind(this);
+    this.historicalInfo = this.historicalInfo.bind(this);
+    this.pool = this.pool.bind(this);
+    this.params = this.params.bind(this);
+  }
+  /* Validators queries all validators that match the given status.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async validators(params: QueryValidatorsRequest): Promise<QueryValidatorsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.status !== "undefined") {
+      options.params.status = params.status;
+    }
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/validators`;
+    return await this.req.get<QueryValidatorsResponseSDKType>(endpoint, options);
+  }
+  /* Validator queries validator info for given validator address. */
+
+
+  async validator(params: QueryValidatorRequest): Promise<QueryValidatorResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/validators/${params.validatorAddr}`;
+    return await this.req.get<QueryValidatorResponseSDKType>(endpoint);
+  }
+  /* ValidatorDelegations queries delegate info for given validator.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async validatorDelegations(params: QueryValidatorDelegationsRequest): Promise<QueryValidatorDelegationsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/validators/${params.validatorAddr}/delegations`;
+    return await this.req.get<QueryValidatorDelegationsResponseSDKType>(endpoint, options);
+  }
+  /* ValidatorUnbondingDelegations queries unbonding delegations of a validator.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async validatorUnbondingDelegations(params: QueryValidatorUnbondingDelegationsRequest): Promise<QueryValidatorUnbondingDelegationsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/validators/${params.validatorAddr}/unbonding_delegations`;
+    return await this.req.get<QueryValidatorUnbondingDelegationsResponseSDKType>(endpoint, options);
+  }
+  /* Delegation queries delegate info for given validator delegator pair. */
+
+
+  async delegation(params: QueryDelegationRequest): Promise<QueryDelegationResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/validators/${params.validatorAddr}/delegations/${params.delegatorAddr}`;
+    return await this.req.get<QueryDelegationResponseSDKType>(endpoint);
+  }
+  /* UnbondingDelegation queries unbonding info for given validator delegator
+   pair. */
+
+
+  async unbondingDelegation(params: QueryUnbondingDelegationRequest): Promise<QueryUnbondingDelegationResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/validators/${params.validatorAddr}/delegations/${params.delegatorAddr}/unbonding_delegation`;
+    return await this.req.get<QueryUnbondingDelegationResponseSDKType>(endpoint);
+  }
+  /* DelegatorDelegations queries all delegations of a given delegator address.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async delegatorDelegations(params: QueryDelegatorDelegationsRequest): Promise<QueryDelegatorDelegationsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/delegations/${params.delegatorAddr}`;
+    return await this.req.get<QueryDelegatorDelegationsResponseSDKType>(endpoint, options);
+  }
+  /* DelegatorUnbondingDelegations queries all unbonding delegations of a given
+   delegator address.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async delegatorUnbondingDelegations(params: QueryDelegatorUnbondingDelegationsRequest): Promise<QueryDelegatorUnbondingDelegationsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/delegators/${params.delegatorAddr}/unbonding_delegations`;
+    return await this.req.get<QueryDelegatorUnbondingDelegationsResponseSDKType>(endpoint, options);
+  }
+  /* Redelegations queries redelegations of given address.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async redelegations(params: QueryRedelegationsRequest): Promise<QueryRedelegationsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.srcValidatorAddr !== "undefined") {
+      options.params.src_validator_addr = params.srcValidatorAddr;
+    }
+
+    if (typeof params?.dstValidatorAddr !== "undefined") {
+      options.params.dst_validator_addr = params.dstValidatorAddr;
+    }
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/delegators/${params.delegatorAddr}/redelegations`;
+    return await this.req.get<QueryRedelegationsResponseSDKType>(endpoint, options);
+  }
+  /* DelegatorValidators queries all validators info for given delegator
+   address.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+
+
+  async delegatorValidators(params: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/staking/v1beta1/delegators/${params.delegatorAddr}/validators`;
+    return await this.req.get<QueryDelegatorValidatorsResponseSDKType>(endpoint, options);
+  }
+  /* DelegatorValidator queries validator info for given delegator validator
+   pair. */
+
+
+  async delegatorValidator(params: QueryDelegatorValidatorRequest): Promise<QueryDelegatorValidatorResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/delegators/${params.delegatorAddr}/validators/${params.validatorAddr}`;
+    return await this.req.get<QueryDelegatorValidatorResponseSDKType>(endpoint);
+  }
+  /* HistoricalInfo queries the historical info for given height. */
+
+
+  async historicalInfo(params: QueryHistoricalInfoRequest): Promise<QueryHistoricalInfoResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/historical_info/${params.height}`;
+    return await this.req.get<QueryHistoricalInfoResponseSDKType>(endpoint);
+  }
+  /* Pool queries the pool info. */
+
+
+  async pool(_params: QueryPoolRequest = {}): Promise<QueryPoolResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/pool`;
+    return await this.req.get<QueryPoolResponseSDKType>(endpoint);
+  }
+  /* Parameters queries the staking parameters. */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/staking/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+
+}