@xpla/xpla-react 1.7.0-beta.0

package/src/cosmos/evidence/module/v1/module.ts

@@ -0,0 +1,80 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Module is the config object of the evidence module. */
+export interface Module {}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.evidence.module.v1.Module";
+  value: Uint8Array;
+}
+/** Module is the config object of the evidence module. */
+export interface ModuleAmino {}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+function createBaseModule(): Module {
+  return {};
+}
+export const Module = {
+  typeUrl: "/cosmos.evidence.module.v1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && o.$typeUrl === Module.typeUrl;
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && o.$typeUrl === Module.typeUrl;
+  },
+  encode(_: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    return message;
+  },
+  fromAmino(_: ModuleAmino): Module {
+    const message = createBaseModule();
+    return message;
+  },
+  toAmino(_: Module): ModuleAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

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

@@ -0,0 +1,154 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp, DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * Equivocation implements the Evidence interface and defines evidence of double
+ * signing misbehavior.
+ */
+export interface Equivocation {
+  /** height is the equivocation height. */
+  height: bigint;
+  /** time is the equivocation time. */
+  time: Date;
+  /** power is the equivocation validator power. */
+  power: bigint;
+  /** consensus_address is the equivocation validator consensus address. */
+  consensusAddress: string;
+}
+export interface EquivocationProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.Equivocation";
+  value: Uint8Array;
+}
+/**
+ * Equivocation implements the Evidence interface and defines evidence of double
+ * signing misbehavior.
+ */
+export interface EquivocationAmino {
+  /** height is the equivocation height. */
+  height: string;
+  /** time is the equivocation time. */
+  time: string;
+  /** power is the equivocation validator power. */
+  power: string;
+  /** consensus_address is the equivocation validator consensus address. */
+  consensus_address: string;
+}
+export interface EquivocationAminoMsg {
+  type: "cosmos-sdk/Equivocation";
+  value: EquivocationAmino;
+}
+function createBaseEquivocation(): Equivocation {
+  return {
+    height: BigInt(0),
+    time: new Date(),
+    power: BigInt(0),
+    consensusAddress: ""
+  };
+}
+export const Equivocation = {
+  typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+  aminoType: "cosmos-sdk/Equivocation",
+  is(o: any): o is Equivocation {
+    return o && (o.$typeUrl === Equivocation.typeUrl || typeof o.height === "bigint" && Timestamp.is(o.time) && typeof o.power === "bigint" && typeof o.consensusAddress === "string");
+  },
+  isAmino(o: any): o is EquivocationAmino {
+    return o && (o.$typeUrl === Equivocation.typeUrl || typeof o.height === "bigint" && Timestamp.isAmino(o.time) && typeof o.power === "bigint" && typeof o.consensus_address === "string");
+  },
+  encode(message: Equivocation, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.height !== BigInt(0)) {
+      writer.uint32(8).int64(message.height);
+    }
+    if (message.time !== undefined) {
+      Timestamp.encode(toTimestamp(message.time), writer.uint32(18).fork()).ldelim();
+    }
+    if (message.power !== BigInt(0)) {
+      writer.uint32(24).int64(message.power);
+    }
+    if (message.consensusAddress !== "") {
+      writer.uint32(34).string(message.consensusAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Equivocation {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEquivocation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.int64();
+          break;
+        case 2:
+          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.power = reader.int64();
+          break;
+        case 4:
+          message.consensusAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Equivocation>): Equivocation {
+    const message = createBaseEquivocation();
+    message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+    message.time = object.time ?? undefined;
+    message.power = object.power !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
+    message.consensusAddress = object.consensusAddress ?? "";
+    return message;
+  },
+  fromAmino(object: EquivocationAmino): Equivocation {
+    const message = createBaseEquivocation();
+    if (object.height !== undefined && object.height !== null) {
+      message.height = BigInt(object.height);
+    }
+    if (object.time !== undefined && object.time !== null) {
+      message.time = fromTimestamp(Timestamp.fromAmino(object.time));
+    }
+    if (object.power !== undefined && object.power !== null) {
+      message.power = BigInt(object.power);
+    }
+    if (object.consensus_address !== undefined && object.consensus_address !== null) {
+      message.consensusAddress = object.consensus_address;
+    }
+    return message;
+  },
+  toAmino(message: Equivocation): EquivocationAmino {
+    const obj: any = {};
+    obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+    obj.time = message.time ? Timestamp.toAmino(toTimestamp(message.time)) : new Date();
+    obj.power = message.power !== BigInt(0) ? message.power?.toString() : undefined;
+    obj.consensus_address = message.consensusAddress === "" ? undefined : message.consensusAddress;
+    return obj;
+  },
+  fromAminoMsg(object: EquivocationAminoMsg): Equivocation {
+    return Equivocation.fromAmino(object.value);
+  },
+  toAminoMsg(message: Equivocation): EquivocationAminoMsg {
+    return {
+      type: "cosmos-sdk/Equivocation",
+      value: Equivocation.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EquivocationProtoMsg): Equivocation {
+    return Equivocation.decode(message.value);
+  },
+  toProto(message: Equivocation): Uint8Array {
+    return Equivocation.encode(message).finish();
+  },
+  toProtoMsg(message: Equivocation): EquivocationProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+      value: Equivocation.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Equivocation.typeUrl, Equivocation);
+GlobalDecoderRegistry.registerAminoProtoMapping(Equivocation.aminoType, Equivocation.typeUrl);

package/src/cosmos/evidence/v1beta1/genesis.ts

@@ -0,0 +1,102 @@
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** GenesisState defines the evidence module's genesis state. */
+export interface GenesisState {
+  /** evidence defines all the evidence at genesis. */
+  evidence: Any[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the evidence module's genesis state. */
+export interface GenesisStateAmino {
+  /** evidence defines all the evidence at genesis. */
+  evidence: AnyAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    evidence: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.evidence.v1beta1.GenesisState",
+  aminoType: "cosmos-sdk/GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.evidence) && (!o.evidence.length || Any.is(o.evidence[0])));
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.evidence) && (!o.evidence.length || Any.isAmino(o.evidence[0])));
+  },
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.evidence) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new 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.evidence.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.evidence = object.evidence?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.evidence = object.evidence?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.evidence) {
+      obj.evidence = message.evidence.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.evidence = message.evidence;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
+GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

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

@@ -0,0 +1,25 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { buildUseQuery } from "../../../react-query";
+import { QueryEvidenceRequest, QueryEvidenceResponse, QueryAllEvidenceRequest, QueryAllEvidenceResponse } from "./query";
+export const createGetEvidence = (clientResolver?: RpcResolver) => buildQuery<QueryEvidenceRequest, QueryEvidenceResponse>({
+  encode: QueryEvidenceRequest.encode,
+  decode: QueryEvidenceResponse.decode,
+  service: "cosmos.evidence.v1beta1.Query",
+  method: "Evidence",
+  clientResolver
+});
+export const useGetEvidence = buildUseQuery<QueryEvidenceRequest, QueryEvidenceResponse>({
+  builderQueryFn: createGetEvidence,
+  queryKeyPrefix: "EvidenceQuery"
+});
+export const createGetAllEvidence = (clientResolver?: RpcResolver) => buildQuery<QueryAllEvidenceRequest, QueryAllEvidenceResponse>({
+  encode: QueryAllEvidenceRequest.encode,
+  decode: QueryAllEvidenceResponse.decode,
+  service: "cosmos.evidence.v1beta1.Query",
+  method: "AllEvidence",
+  clientResolver
+});
+export const useGetAllEvidence = buildUseQuery<QueryAllEvidenceRequest, QueryAllEvidenceResponse>({
+  builderQueryFn: createGetAllEvidence,
+  queryKeyPrefix: "AllEvidenceQuery"
+});