@iconlake/client 0.0.1

package/cosmos.staking.v1beta1/types/cosmos/staking/v1beta1/authz.ts

@@ -0,0 +1,245 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Coin } from "../../base/v1beta1/coin";
+
+export const protobufPackage = "cosmos.staking.v1beta1";
+
+/**
+ * AuthorizationType defines the type of staking module authorization type
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export 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,
+  UNRECOGNIZED = -1,
+}
+
+export function authorizationTypeFromJSON(object: any): AuthorizationType {
+  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 -1:
+    case "UNRECOGNIZED":
+    default:
+      return AuthorizationType.UNRECOGNIZED;
+  }
+}
+
+export function authorizationTypeToJSON(object: AuthorizationType): string {
+  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.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export 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
+    | undefined;
+  /**
+   * allow_list specifies list of validator addresses to whom grantee can delegate tokens on behalf of granter's
+   * account.
+   */
+  allowList:
+    | StakeAuthorization_Validators
+    | undefined;
+  /** deny_list specifies list of validator addresses to whom grantee can not delegate tokens. */
+  denyList:
+    | StakeAuthorization_Validators
+    | undefined;
+  /** authorization_type defines one of AuthorizationType. */
+  authorizationType: AuthorizationType;
+}
+
+/** Validators defines list of validator addresses. */
+export interface StakeAuthorization_Validators {
+  address: string[];
+}
+
+function createBaseStakeAuthorization(): StakeAuthorization {
+  return { maxTokens: undefined, allowList: undefined, denyList: undefined, authorizationType: 0 };
+}
+
+export const StakeAuthorization = {
+  encode(message: StakeAuthorization, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.maxTokens !== undefined) {
+      Coin.encode(message.maxTokens, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.allowList !== undefined) {
+      StakeAuthorization_Validators.encode(message.allowList, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.denyList !== undefined) {
+      StakeAuthorization_Validators.encode(message.denyList, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.authorizationType !== 0) {
+      writer.uint32(32).int32(message.authorizationType);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StakeAuthorization {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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.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() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StakeAuthorization {
+    return {
+      maxTokens: isSet(object.maxTokens) ? Coin.fromJSON(object.maxTokens) : undefined,
+      allowList: isSet(object.allowList) ? StakeAuthorization_Validators.fromJSON(object.allowList) : undefined,
+      denyList: isSet(object.denyList) ? StakeAuthorization_Validators.fromJSON(object.denyList) : undefined,
+      authorizationType: isSet(object.authorizationType) ? authorizationTypeFromJSON(object.authorizationType) : 0,
+    };
+  },
+
+  toJSON(message: StakeAuthorization): unknown {
+    const obj: any = {};
+    message.maxTokens !== undefined && (obj.maxTokens = message.maxTokens ? Coin.toJSON(message.maxTokens) : undefined);
+    message.allowList !== undefined
+      && (obj.allowList = message.allowList ? StakeAuthorization_Validators.toJSON(message.allowList) : undefined);
+    message.denyList !== undefined
+      && (obj.denyList = message.denyList ? StakeAuthorization_Validators.toJSON(message.denyList) : undefined);
+    message.authorizationType !== undefined
+      && (obj.authorizationType = authorizationTypeToJSON(message.authorizationType));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<StakeAuthorization>, I>>(object: I): StakeAuthorization {
+    const message = createBaseStakeAuthorization();
+    message.maxTokens = (object.maxTokens !== undefined && object.maxTokens !== null)
+      ? Coin.fromPartial(object.maxTokens)
+      : undefined;
+    message.allowList = (object.allowList !== undefined && object.allowList !== null)
+      ? StakeAuthorization_Validators.fromPartial(object.allowList)
+      : undefined;
+    message.denyList = (object.denyList !== undefined && object.denyList !== null)
+      ? StakeAuthorization_Validators.fromPartial(object.denyList)
+      : undefined;
+    message.authorizationType = object.authorizationType ?? 0;
+    return message;
+  },
+};
+
+function createBaseStakeAuthorization_Validators(): StakeAuthorization_Validators {
+  return { address: [] };
+}
+
+export const StakeAuthorization_Validators = {
+  encode(message: StakeAuthorization_Validators, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.address) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StakeAuthorization_Validators {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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;
+  },
+
+  fromJSON(object: any): StakeAuthorization_Validators {
+    return { address: Array.isArray(object?.address) ? object.address.map((e: any) => String(e)) : [] };
+  },
+
+  toJSON(message: StakeAuthorization_Validators): unknown {
+    const obj: any = {};
+    if (message.address) {
+      obj.address = message.address.map((e) => e);
+    } else {
+      obj.address = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<StakeAuthorization_Validators>, I>>(
+    object: I,
+  ): StakeAuthorization_Validators {
+    const message = createBaseStakeAuthorization_Validators();
+    message.address = object.address?.map((e) => e) || [];
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

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

@@ -0,0 +1,322 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Delegation, Params, Redelegation, UnbondingDelegation, Validator } from "./staking";
+
+export const protobufPackage = "cosmos.staking.v1beta1";
+
+/** GenesisState defines the staking module's genesis state. */
+export interface GenesisState {
+  /** params defines all the paramaters of related to deposit. */
+  params:
+    | Params
+    | undefined;
+  /**
+   * 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[];
+  /** delegations 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: 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: number;
+}
+
+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;
+  },
+
+  fromJSON(object: any): GenesisState {
+    return {
+      params: isSet(object.params) ? Params.fromJSON(object.params) : undefined,
+      lastTotalPower: isSet(object.lastTotalPower) ? bytesFromBase64(object.lastTotalPower) : new Uint8Array(),
+      lastValidatorPowers: Array.isArray(object?.lastValidatorPowers)
+        ? object.lastValidatorPowers.map((e: any) => LastValidatorPower.fromJSON(e))
+        : [],
+      validators: Array.isArray(object?.validators) ? object.validators.map((e: any) => Validator.fromJSON(e)) : [],
+      delegations: Array.isArray(object?.delegations) ? object.delegations.map((e: any) => Delegation.fromJSON(e)) : [],
+      unbondingDelegations: Array.isArray(object?.unbondingDelegations)
+        ? object.unbondingDelegations.map((e: any) => UnbondingDelegation.fromJSON(e))
+        : [],
+      redelegations: Array.isArray(object?.redelegations)
+        ? object.redelegations.map((e: any) => Redelegation.fromJSON(e))
+        : [],
+      exported: isSet(object.exported) ? Boolean(object.exported) : false,
+    };
+  },
+
+  toJSON(message: GenesisState): unknown {
+    const obj: any = {};
+    message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
+    message.lastTotalPower !== undefined
+      && (obj.lastTotalPower = base64FromBytes(
+        message.lastTotalPower !== undefined ? message.lastTotalPower : new Uint8Array(),
+      ));
+    if (message.lastValidatorPowers) {
+      obj.lastValidatorPowers = message.lastValidatorPowers.map((e) => e ? LastValidatorPower.toJSON(e) : undefined);
+    } else {
+      obj.lastValidatorPowers = [];
+    }
+    if (message.validators) {
+      obj.validators = message.validators.map((e) => e ? Validator.toJSON(e) : undefined);
+    } else {
+      obj.validators = [];
+    }
+    if (message.delegations) {
+      obj.delegations = message.delegations.map((e) => e ? Delegation.toJSON(e) : undefined);
+    } else {
+      obj.delegations = [];
+    }
+    if (message.unbondingDelegations) {
+      obj.unbondingDelegations = message.unbondingDelegations.map((e) => e ? UnbondingDelegation.toJSON(e) : undefined);
+    } else {
+      obj.unbondingDelegations = [];
+    }
+    if (message.redelegations) {
+      obj.redelegations = message.redelegations.map((e) => e ? Redelegation.toJSON(e) : undefined);
+    } else {
+      obj.redelegations = [];
+    }
+    message.exported !== undefined && (obj.exported = message.exported);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<GenesisState>, I>>(object: I): 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: 0 };
+}
+
+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 !== 0) {
+      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 = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LastValidatorPower {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      power: isSet(object.power) ? Number(object.power) : 0,
+    };
+  },
+
+  toJSON(message: LastValidatorPower): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.power !== undefined && (obj.power = Math.round(message.power));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<LastValidatorPower>, I>>(object: I): LastValidatorPower {
+    const message = createBaseLastValidatorPower();
+    message.address = object.address ?? "";
+    message.power = object.power ?? 0;
+    return message;
+  },
+};
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}