@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/rpc.query.ts

@@ -0,0 +1,82 @@
+import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({
+  rpcEndpoint
+}: {
+  rpcEndpoint: string | HttpEndpoint;
+}) => {
+  const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+  const client = new QueryClient(tmClient);
+  return {
+    cosmos: {
+      app: {
+        v1alpha1: (await import("./app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      auth: {
+        v1beta1: (await import("./auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      authz: {
+        v1beta1: (await import("./authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("./bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      base: {
+        node: {
+          v1beta1: (await import("./base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        },
+        tendermint: {
+          v1beta1: (await import("./base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
+      circuit: {
+        v1: (await import("./circuit/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      consensus: {
+        v1: (await import("./consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("./distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      evidence: {
+        v1beta1: (await import("./evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feegrant: {
+        v1beta1: (await import("./feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      gov: {
+        v1: (await import("./gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+        v1beta1: (await import("./gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      group: {
+        v1: (await import("./group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      mint: {
+        v1beta1: (await import("./mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      nft: {
+        v1beta1: (await import("./nft/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      orm: {
+        query: {
+          v1alpha1: (await import("./orm/query/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+        }
+      },
+      params: {
+        v1beta1: (await import("./params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      slashing: {
+        v1beta1: (await import("./slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      staking: {
+        v1beta1: (await import("./staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("./tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("./upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      }
+    }
+  };
+};

package/src/codegen/cosmos/rpc.tx.ts

@@ -0,0 +1,61 @@
+import { Rpc } from "../helpers";
+export const createRPCMsgClient = async ({
+  rpc
+}: {
+  rpc: Rpc;
+}) => ({
+  cosmos: {
+    auth: {
+      v1beta1: new (await import("./auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    authz: {
+      v1beta1: new (await import("./authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    bank: {
+      v1beta1: new (await import("./bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    circuit: {
+      v1: new (await import("./circuit/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    consensus: {
+      v1: new (await import("./consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    crisis: {
+      v1beta1: new (await import("./crisis/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    distribution: {
+      v1beta1: new (await import("./distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    evidence: {
+      v1beta1: new (await import("./evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feegrant: {
+      v1beta1: new (await import("./feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    gov: {
+      v1: new (await import("./gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+      v1beta1: new (await import("./gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    group: {
+      v1: new (await import("./group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    mint: {
+      v1beta1: new (await import("./mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    nft: {
+      v1beta1: new (await import("./nft/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    slashing: {
+      v1beta1: new (await import("./slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    staking: {
+      v1beta1: new (await import("./staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    upgrade: {
+      v1beta1: new (await import("./upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    vesting: {
+      v1beta1: new (await import("./vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  }
+});

package/src/codegen/cosmos/slashing/module/v1/module.ts

@@ -0,0 +1,58 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the slashing module. */
+
+export interface Module {
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+/** Module is the config object of the slashing module. */
+
+export interface ModuleSDKType {
+  authority: string;
+}
+
+function createBaseModule(): Module {
+  return {
+    authority: ""
+  };
+}
+
+export const Module = {
+  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.authority = object.authority ?? "";
+    return message;
+  }
+
+};

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

@@ -0,0 +1,309 @@
+import { Params, ParamsSDKType, ValidatorSigningInfo, ValidatorSigningInfoSDKType } from "./slashing";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../../helpers";
+/** GenesisState defines the slashing module's genesis state. */
+
+export interface GenesisState {
+  /** params defines all the parameters of the module. */
+  params?: Params;
+  /**
+   * signing_infos represents a map between validator addresses and their
+   * signing infos.
+   */
+
+  signingInfos: SigningInfo[];
+  /**
+   * missed_blocks represents a map between validator addresses and their
+   * missed blocks.
+   */
+
+  missedBlocks: ValidatorMissedBlocks[];
+}
+/** GenesisState defines the slashing module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: ParamsSDKType;
+  signing_infos: SigningInfoSDKType[];
+  missed_blocks: ValidatorMissedBlocksSDKType[];
+}
+/** SigningInfo stores validator signing info of corresponding address. */
+
+export interface SigningInfo {
+  /** address is the validator address. */
+  address: string;
+  /** validator_signing_info represents the signing info of this validator. */
+
+  validatorSigningInfo?: ValidatorSigningInfo;
+}
+/** SigningInfo stores validator signing info of corresponding address. */
+
+export interface SigningInfoSDKType {
+  address: string;
+  validator_signing_info?: ValidatorSigningInfoSDKType;
+}
+/**
+ * ValidatorMissedBlocks contains array of missed blocks of corresponding
+ * address.
+ */
+
+export interface ValidatorMissedBlocks {
+  /** address is the validator address. */
+  address: string;
+  /** missed_blocks is an array of missed blocks by the validator. */
+
+  missedBlocks: MissedBlock[];
+}
+/**
+ * ValidatorMissedBlocks contains array of missed blocks of corresponding
+ * address.
+ */
+
+export interface ValidatorMissedBlocksSDKType {
+  address: string;
+  missed_blocks: MissedBlockSDKType[];
+}
+/** MissedBlock contains height and missed status as boolean. */
+
+export interface MissedBlock {
+  /** index is the height at which the block was missed. */
+  index: Long;
+  /** missed is the missed status. */
+
+  missed: boolean;
+}
+/** MissedBlock contains height and missed status as boolean. */
+
+export interface MissedBlockSDKType {
+  index: Long;
+  missed: boolean;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    signingInfos: [],
+    missedBlocks: []
+  };
+}
+
+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();
+    }
+
+    for (const v of message.signingInfos) {
+      SigningInfo.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.missedBlocks) {
+      ValidatorMissedBlocks.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    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.signingInfos.push(SigningInfo.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.missedBlocks.push(ValidatorMissedBlocks.decode(reader, reader.uint32()));
+          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.signingInfos = object.signingInfos?.map(e => SigningInfo.fromPartial(e)) || [];
+    message.missedBlocks = object.missedBlocks?.map(e => ValidatorMissedBlocks.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseSigningInfo(): SigningInfo {
+  return {
+    address: "",
+    validatorSigningInfo: undefined
+  };
+}
+
+export const SigningInfo = {
+  encode(message: SigningInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    if (message.validatorSigningInfo !== undefined) {
+      ValidatorSigningInfo.encode(message.validatorSigningInfo, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SigningInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSigningInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.validatorSigningInfo = ValidatorSigningInfo.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SigningInfo>): SigningInfo {
+    const message = createBaseSigningInfo();
+    message.address = object.address ?? "";
+    message.validatorSigningInfo = object.validatorSigningInfo !== undefined && object.validatorSigningInfo !== null ? ValidatorSigningInfo.fromPartial(object.validatorSigningInfo) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseValidatorMissedBlocks(): ValidatorMissedBlocks {
+  return {
+    address: "",
+    missedBlocks: []
+  };
+}
+
+export const ValidatorMissedBlocks = {
+  encode(message: ValidatorMissedBlocks, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    for (const v of message.missedBlocks) {
+      MissedBlock.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorMissedBlocks {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidatorMissedBlocks();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.missedBlocks.push(MissedBlock.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ValidatorMissedBlocks>): ValidatorMissedBlocks {
+    const message = createBaseValidatorMissedBlocks();
+    message.address = object.address ?? "";
+    message.missedBlocks = object.missedBlocks?.map(e => MissedBlock.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseMissedBlock(): MissedBlock {
+  return {
+    index: Long.ZERO,
+    missed: false
+  };
+}
+
+export const MissedBlock = {
+  encode(message: MissedBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.index.isZero()) {
+      writer.uint32(8).int64(message.index);
+    }
+
+    if (message.missed === true) {
+      writer.uint32(16).bool(message.missed);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MissedBlock {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMissedBlock();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.index = (reader.int64() as Long);
+          break;
+
+        case 2:
+          message.missed = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MissedBlock>): MissedBlock {
+    const message = createBaseMissedBlock();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.ZERO;
+    message.missed = object.missed ?? false;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,49 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QuerySigningInfoRequest, QuerySigningInfoResponseSDKType, QuerySigningInfosRequest, QuerySigningInfosResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.signingInfo = this.signingInfo.bind(this);
+    this.signingInfos = this.signingInfos.bind(this);
+  }
+  /* Params queries the parameters of slashing module */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/slashing/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* SigningInfo queries the signing info of given cons address */
+
+
+  async signingInfo(params: QuerySigningInfoRequest): Promise<QuerySigningInfoResponseSDKType> {
+    const endpoint = `cosmos/slashing/v1beta1/signing_infos/${params.consAddress}`;
+    return await this.req.get<QuerySigningInfoResponseSDKType>(endpoint);
+  }
+  /* SigningInfos queries signing info of all validators */
+
+
+  async signingInfos(params: QuerySigningInfosRequest = {
+    pagination: undefined
+  }): Promise<QuerySigningInfosResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/slashing/v1beta1/signing_infos`;
+    return await this.req.get<QuerySigningInfosResponseSDKType>(endpoint, options);
+  }
+
+}

package/src/codegen/cosmos/slashing/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,65 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QuerySigningInfoRequest, QuerySigningInfoResponse, QuerySigningInfosRequest, QuerySigningInfosResponse } from "./query";
+/** Query provides defines the gRPC querier service */
+
+export interface Query {
+  /** Params queries the parameters of slashing module */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** SigningInfo queries the signing info of given cons address */
+
+  signingInfo(request: QuerySigningInfoRequest): Promise<QuerySigningInfoResponse>;
+  /** SigningInfos queries signing info of all validators */
+
+  signingInfos(request?: QuerySigningInfosRequest): Promise<QuerySigningInfosResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.signingInfo = this.signingInfo.bind(this);
+    this.signingInfos = this.signingInfos.bind(this);
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  signingInfo(request: QuerySigningInfoRequest): Promise<QuerySigningInfoResponse> {
+    const data = QuerySigningInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfo", data);
+    return promise.then(data => QuerySigningInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  signingInfos(request: QuerySigningInfosRequest = {
+    pagination: undefined
+  }): Promise<QuerySigningInfosResponse> {
+    const data = QuerySigningInfosRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfos", data);
+    return promise.then(data => QuerySigningInfosResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+
+    signingInfo(request: QuerySigningInfoRequest): Promise<QuerySigningInfoResponse> {
+      return queryService.signingInfo(request);
+    },
+
+    signingInfos(request?: QuerySigningInfosRequest): Promise<QuerySigningInfosResponse> {
+      return queryService.signingInfos(request);
+    }
+
+  };
+};