juno-network 0.5.3 → 0.6.0

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

@@ -0,0 +1,37 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Any } from "../../../google/protobuf/any";
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryEvidenceRequest, QueryEvidenceResponse, QueryAllEvidenceRequest, QueryAllEvidenceResponse } from "./query";
+
+/** Query defines the RPC service */
+export interface Query {
+  evidence(request: QueryEvidenceRequest): Promise<QueryEvidenceResponse>;
+  /*Evidence queries evidence based on evidence hash.*/
+
+  allEvidence(request: QueryAllEvidenceRequest): Promise<QueryAllEvidenceResponse>;
+  /*AllEvidence queries all evidence.*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.evidence = this.evidence.bind(this);
+    this.allEvidence = this.allEvidence.bind(this);
+  }
+
+  evidence(request: QueryEvidenceRequest): Promise<QueryEvidenceResponse> {
+    const data = QueryEvidenceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Query", "Evidence", data);
+    return promise.then(data => QueryEvidenceResponse.decode(new _m0.Reader(data)));
+  }
+
+  allEvidence(request: QueryAllEvidenceRequest): Promise<QueryAllEvidenceResponse> {
+    const data = QueryAllEvidenceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Query", "AllEvidence", data);
+    return promise.then(data => QueryAllEvidenceResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/cosmos/evidence/v1beta1/query.ts

@@ -0,0 +1,283 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { isSet, bytesFromBase64, base64FromBytes, DeepPartial } from "@osmonauts/helpers";
+
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequest {
+  /** evidence_hash defines the hash of the requested evidence. */
+  evidence_hash: Uint8Array;
+}
+
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponse {
+  /** evidence returns the requested evidence. */
+  evidence: Any;
+}
+
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequest {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequest;
+}
+
+/**
+ * QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceResponse {
+  /** evidence returns all evidences. */
+  evidence: Any[];
+
+  /** pagination defines the pagination in the response. */
+  pagination?: PageResponse;
+}
+
+function createBaseQueryEvidenceRequest(): QueryEvidenceRequest {
+  return {
+    evidence_hash: new Uint8Array()
+  };
+}
+
+export const QueryEvidenceRequest = {
+  encode(message: QueryEvidenceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.evidence_hash.length !== 0) {
+      writer.uint32(10).bytes(message.evidence_hash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryEvidenceRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEvidenceRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.evidence_hash = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): QueryEvidenceRequest {
+    return {
+      evidence_hash: isSet(object.evidence_hash) ? bytesFromBase64(object.evidence_hash) : new Uint8Array()
+    };
+  },
+
+  toJSON(message: QueryEvidenceRequest): unknown {
+    const obj: any = {};
+    message.evidence_hash !== undefined && (obj.evidence_hash = base64FromBytes(message.evidence_hash !== undefined ? message.evidence_hash : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<QueryEvidenceRequest>): QueryEvidenceRequest {
+    const message = createBaseQueryEvidenceRequest();
+    message.evidence_hash = object.evidence_hash ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseQueryEvidenceResponse(): QueryEvidenceResponse {
+  return {
+    evidence: undefined
+  };
+}
+
+export const QueryEvidenceResponse = {
+  encode(message: QueryEvidenceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.evidence !== undefined) {
+      Any.encode(message.evidence, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryEvidenceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEvidenceResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.evidence = Any.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): QueryEvidenceResponse {
+    return {
+      evidence: isSet(object.evidence) ? Any.fromJSON(object.evidence) : undefined
+    };
+  },
+
+  toJSON(message: QueryEvidenceResponse): unknown {
+    const obj: any = {};
+    message.evidence !== undefined && (obj.evidence = message.evidence ? Any.toJSON(message.evidence) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<QueryEvidenceResponse>): QueryEvidenceResponse {
+    const message = createBaseQueryEvidenceResponse();
+    message.evidence = object.evidence !== undefined && object.evidence !== null ? Any.fromPartial(object.evidence) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryAllEvidenceRequest(): QueryAllEvidenceRequest {
+  return {
+    pagination: undefined
+  };
+}
+
+export const QueryAllEvidenceRequest = {
+  encode(message: QueryAllEvidenceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllEvidenceRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllEvidenceRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): QueryAllEvidenceRequest {
+    return {
+      pagination: isSet(object.pagination) ? PageRequest.fromJSON(object.pagination) : undefined
+    };
+  },
+
+  toJSON(message: QueryAllEvidenceRequest): unknown {
+    const obj: any = {};
+    message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<QueryAllEvidenceRequest>): QueryAllEvidenceRequest {
+    const message = createBaseQueryAllEvidenceRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryAllEvidenceResponse(): QueryAllEvidenceResponse {
+  return {
+    evidence: [],
+    pagination: undefined
+  };
+}
+
+export const QueryAllEvidenceResponse = {
+  encode(message: QueryAllEvidenceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.evidence) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllEvidenceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllEvidenceResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.evidence.push(Any.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): QueryAllEvidenceResponse {
+    return {
+      evidence: Array.isArray(object?.evidence) ? object.evidence.map((e: any) => Any.fromJSON(e)) : [],
+      pagination: isSet(object.pagination) ? PageResponse.fromJSON(object.pagination) : undefined
+    };
+  },
+
+  toJSON(message: QueryAllEvidenceResponse): unknown {
+    const obj: any = {};
+
+    if (message.evidence) {
+      obj.evidence = message.evidence.map(e => e ? Any.toJSON(e) : undefined);
+    } else {
+      obj.evidence = [];
+    }
+
+    message.pagination !== undefined && (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<QueryAllEvidenceResponse>): QueryAllEvidenceResponse {
+    const message = createBaseQueryAllEvidenceResponse();
+    message.evidence = object.evidence?.map(e => Any.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/evidence/v1beta1/tx.amino.ts

@@ -0,0 +1,42 @@
+import { Any } from "../../../google/protobuf/any";
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgSubmitEvidence } from "./tx";
+export interface AminoMsgSubmitEvidence extends AminoMsg {
+  type: "cosmos-sdk/MsgSubmitEvidence";
+  value: {
+    submitter: string;
+    evidence: {
+      type_url: string;
+      value: Uint8Array;
+    };
+  };
+}
+export const AminoConverter = {
+  "/cosmos.evidence.v1beta1.MsgSubmitEvidence": {
+    aminoType: "cosmos-sdk/MsgSubmitEvidence",
+    toAmino: ({
+      submitter,
+      evidence
+    }: MsgSubmitEvidence): AminoMsgSubmitEvidence["value"] => {
+      return {
+        submitter,
+        evidence: {
+          type_url: evidence.type_url,
+          value: evidence.value
+        }
+      };
+    },
+    fromAmino: ({
+      submitter,
+      evidence
+    }: AminoMsgSubmitEvidence["value"]): MsgSubmitEvidence => {
+      return {
+        submitter,
+        evidence: {
+          type_url: evidence.type_url,
+          value: evidence.value
+        }
+      };
+    }
+  }
+};

package/src/codegen/cosmos/evidence/v1beta1/tx.registry.ts

@@ -0,0 +1,56 @@
+import { Any } from "../../../google/protobuf/any";
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSubmitEvidence } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.evidence.v1beta1.MsgSubmitEvidence", MsgSubmitEvidence]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    submitEvidence(value: MsgSubmitEvidence) {
+      return {
+        typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+        value: MsgSubmitEvidence.encode(value).finish()
+      };
+    }
+
+  },
+  withTypeUrl: {
+    submitEvidence(value: MsgSubmitEvidence) {
+      return {
+        typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+        value
+      };
+    }
+
+  },
+  toJSON: {
+    submitEvidence(value: MsgSubmitEvidence) {
+      return {
+        typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+        value: MsgSubmitEvidence.toJSON(value)
+      };
+    }
+
+  },
+  fromJSON: {
+    submitEvidence(value: any) {
+      return {
+        typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+        value: MsgSubmitEvidence.fromJSON(value)
+      };
+    }
+
+  },
+  fromPartial: {
+    submitEvidence(value: MsgSubmitEvidence) {
+      return {
+        typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+        value: MsgSubmitEvidence.fromPartial(value)
+      };
+    }
+
+  }
+};

package/src/codegen/cosmos/evidence/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,27 @@
+import { Any } from "../../../google/protobuf/any";
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgSubmitEvidence, MsgSubmitEvidenceResponse } from "./tx";
+
+/** Msg defines the RPC service */
+export interface Msg {
+  submitEvidence(request: MsgSubmitEvidence): Promise<MsgSubmitEvidenceResponse>;
+  /*SubmitEvidence submits an arbitrary Evidence of misbehavior such as equivocation or
+  counterfactual signing.*/
+
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.submitEvidence = this.submitEvidence.bind(this);
+  }
+
+  submitEvidence(request: MsgSubmitEvidence): Promise<MsgSubmitEvidenceResponse> {
+    const data = MsgSubmitEvidence.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Msg", "SubmitEvidence", data);
+    return promise.then(data => MsgSubmitEvidenceResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/cosmos/evidence/v1beta1/tx.ts

@@ -0,0 +1,144 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { isSet, DeepPartial, bytesFromBase64, base64FromBytes } from "@osmonauts/helpers";
+
+/**
+ * MsgSubmitEvidence represents a message that supports submitting arbitrary
+ * Evidence of misbehavior such as equivocation or counterfactual signing.
+ */
+export interface MsgSubmitEvidence {
+  submitter: string;
+  evidence: Any;
+}
+
+/** MsgSubmitEvidenceResponse defines the Msg/SubmitEvidence response type. */
+export interface MsgSubmitEvidenceResponse {
+  /** hash defines the hash of the evidence. */
+  hash: Uint8Array;
+}
+
+function createBaseMsgSubmitEvidence(): MsgSubmitEvidence {
+  return {
+    submitter: "",
+    evidence: undefined
+  };
+}
+
+export const MsgSubmitEvidence = {
+  encode(message: MsgSubmitEvidence, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.submitter !== "") {
+      writer.uint32(10).string(message.submitter);
+    }
+
+    if (message.evidence !== undefined) {
+      Any.encode(message.evidence, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSubmitEvidence {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitEvidence();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.submitter = reader.string();
+          break;
+
+        case 2:
+          message.evidence = Any.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): MsgSubmitEvidence {
+    return {
+      submitter: isSet(object.submitter) ? String(object.submitter) : "",
+      evidence: isSet(object.evidence) ? Any.fromJSON(object.evidence) : undefined
+    };
+  },
+
+  toJSON(message: MsgSubmitEvidence): unknown {
+    const obj: any = {};
+    message.submitter !== undefined && (obj.submitter = message.submitter);
+    message.evidence !== undefined && (obj.evidence = message.evidence ? Any.toJSON(message.evidence) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgSubmitEvidence>): MsgSubmitEvidence {
+    const message = createBaseMsgSubmitEvidence();
+    message.submitter = object.submitter ?? "";
+    message.evidence = object.evidence !== undefined && object.evidence !== null ? Any.fromPartial(object.evidence) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgSubmitEvidenceResponse(): MsgSubmitEvidenceResponse {
+  return {
+    hash: new Uint8Array()
+  };
+}
+
+export const MsgSubmitEvidenceResponse = {
+  encode(message: MsgSubmitEvidenceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash.length !== 0) {
+      writer.uint32(34).bytes(message.hash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSubmitEvidenceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitEvidenceResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 4:
+          message.hash = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): MsgSubmitEvidenceResponse {
+    return {
+      hash: isSet(object.hash) ? bytesFromBase64(object.hash) : new Uint8Array()
+    };
+  },
+
+  toJSON(message: MsgSubmitEvidenceResponse): unknown {
+    const obj: any = {};
+    message.hash !== undefined && (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgSubmitEvidenceResponse>): MsgSubmitEvidenceResponse {
+    const message = createBaseMsgSubmitEvidenceResponse();
+    message.hash = object.hash ?? new Uint8Array();
+    return message;
+  }
+
+};