@xpla/xplajs 1.7.0-beta.2 → 1.7.0-beta.4

package/dist/cosmos/evidence/module/v1/module.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+function createBaseModule() {
+    return {};
+}
+exports.Module = {
+    typeUrl: "/cosmos.evidence.module.v1.Module",
+    aminoType: "cosmos-sdk/Module",
+    is(o) {
+        return o && o.$typeUrl === exports.Module.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.Module.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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(_) {
+        const message = createBaseModule();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseModule();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Module.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Module",
+            value: exports.Module.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Module.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.evidence.module.v1.Module",
+            value: exports.Module.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Module.typeUrl, exports.Module);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Module.aminoType, exports.Module.typeUrl);

package/dist/cosmos/evidence/v1beta1/evidence.d.ts

@@ -0,0 +1,54 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * 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;
+}
+export declare const Equivocation: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Equivocation;
+    isAmino(o: any): o is EquivocationAmino;
+    encode(message: Equivocation, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Equivocation;
+    fromPartial(object: DeepPartial<Equivocation>): Equivocation;
+    fromAmino(object: EquivocationAmino): Equivocation;
+    toAmino(message: Equivocation): EquivocationAmino;
+    fromAminoMsg(object: EquivocationAminoMsg): Equivocation;
+    toAminoMsg(message: Equivocation): EquivocationAminoMsg;
+    fromProtoMsg(message: EquivocationProtoMsg): Equivocation;
+    toProto(message: Equivocation): Uint8Array;
+    toProtoMsg(message: Equivocation): EquivocationProtoMsg;
+};

package/dist/cosmos/evidence/v1beta1/evidence.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Equivocation = void 0;
+const timestamp_1 = require("../../../google/protobuf/timestamp");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBaseEquivocation() {
+    return {
+        height: BigInt(0),
+        time: new Date(),
+        power: BigInt(0),
+        consensusAddress: ""
+    };
+}
+exports.Equivocation = {
+    typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+    aminoType: "cosmos-sdk/Equivocation",
+    is(o) {
+        return o && (o.$typeUrl === exports.Equivocation.typeUrl || typeof o.height === "bigint" && timestamp_1.Timestamp.is(o.time) && typeof o.power === "bigint" && typeof o.consensusAddress === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Equivocation.typeUrl || typeof o.height === "bigint" && timestamp_1.Timestamp.isAmino(o.time) && typeof o.power === "bigint" && typeof o.consensus_address === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.height !== BigInt(0)) {
+            writer.uint32(8).int64(message.height);
+        }
+        if (message.time !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.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, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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 = (0, helpers_1.fromTimestamp)(timestamp_1.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) {
+        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) {
+        const message = createBaseEquivocation();
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.time !== undefined && object.time !== null) {
+            message.time = (0, helpers_1.fromTimestamp)(timestamp_1.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) {
+        const obj = {};
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        obj.time = message.time ? timestamp_1.Timestamp.toAmino((0, helpers_1.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) {
+        return exports.Equivocation.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Equivocation",
+            value: exports.Equivocation.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Equivocation.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Equivocation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+            value: exports.Equivocation.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Equivocation.typeUrl, exports.Equivocation);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Equivocation.aminoType, exports.Equivocation.typeUrl);

package/dist/cosmos/evidence/v1beta1/genesis.d.ts

@@ -0,0 +1,37 @@
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** 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;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/dist/cosmos/evidence/v1beta1/genesis.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+const any_1 = require("../../../google/protobuf/any");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseGenesisState() {
+    return {
+        evidence: []
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/cosmos.evidence.v1beta1.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.evidence) && (!o.evidence.length || any_1.Any.is(o.evidence[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.evidence) && (!o.evidence.length || any_1.Any.isAmino(o.evidence[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.evidence) {
+            any_1.Any.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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_1.Any.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.evidence = object.evidence?.map(e => any_1.Any.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.evidence = object.evidence?.map(e => any_1.Any.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.evidence) {
+            obj.evidence = message.evidence.map(e => e ? any_1.Any.toAmino(e) : undefined);
+        }
+        else {
+            obj.evidence = message.evidence;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: exports.GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.evidence.v1beta1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.GenesisState.aminoType, exports.GenesisState.typeUrl);

package/dist/cosmos/evidence/v1beta1/query.d.ts

@@ -0,0 +1,176 @@
+import { PageRequest, PageRequestAmino, PageResponse, PageResponseAmino } from "../../base/query/v1beta1/pagination";
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequest {
+    /**
+     * evidence_hash defines the hash of the requested evidence.
+     * Deprecated: Use hash, a HEX encoded string, instead.
+     */
+    /** @deprecated */
+    evidenceHash: Uint8Array;
+    /**
+     * hash defines the evidence hash of the requested evidence.
+     *
+     * Since: cosmos-sdk 0.47
+     */
+    hash: string;
+}
+export interface QueryEvidenceRequestProtoMsg {
+    typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceRequest";
+    value: Uint8Array;
+}
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequestAmino {
+    /**
+     * evidence_hash defines the hash of the requested evidence.
+     * Deprecated: Use hash, a HEX encoded string, instead.
+     */
+    /** @deprecated */
+    evidence_hash: string;
+    /**
+     * hash defines the evidence hash of the requested evidence.
+     *
+     * Since: cosmos-sdk 0.47
+     */
+    hash: string;
+}
+export interface QueryEvidenceRequestAminoMsg {
+    type: "cosmos-sdk/QueryEvidenceRequest";
+    value: QueryEvidenceRequestAmino;
+}
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponse {
+    /** evidence returns the requested evidence. */
+    evidence?: Any;
+}
+export interface QueryEvidenceResponseProtoMsg {
+    typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceResponse";
+    value: Uint8Array;
+}
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponseAmino {
+    /** evidence returns the requested evidence. */
+    evidence?: AnyAmino;
+}
+export interface QueryEvidenceResponseAminoMsg {
+    type: "cosmos-sdk/QueryEvidenceResponse";
+    value: QueryEvidenceResponseAmino;
+}
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+export interface QueryAllEvidenceRequestProtoMsg {
+    typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequestAmino {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestAmino;
+}
+export interface QueryAllEvidenceRequestAminoMsg {
+    type: "cosmos-sdk/QueryAllEvidenceRequest";
+    value: QueryAllEvidenceRequestAmino;
+}
+/**
+ * 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;
+}
+export interface QueryAllEvidenceResponseProtoMsg {
+    typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceResponseAmino {
+    /** evidence returns all evidences. */
+    evidence: AnyAmino[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponseAmino;
+}
+export interface QueryAllEvidenceResponseAminoMsg {
+    type: "cosmos-sdk/QueryAllEvidenceResponse";
+    value: QueryAllEvidenceResponseAmino;
+}
+export declare const QueryEvidenceRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryEvidenceRequest;
+    isAmino(o: any): o is QueryEvidenceRequestAmino;
+    encode(message: QueryEvidenceRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryEvidenceRequest;
+    fromPartial(object: DeepPartial<QueryEvidenceRequest>): QueryEvidenceRequest;
+    fromAmino(object: QueryEvidenceRequestAmino): QueryEvidenceRequest;
+    toAmino(message: QueryEvidenceRequest): QueryEvidenceRequestAmino;
+    fromAminoMsg(object: QueryEvidenceRequestAminoMsg): QueryEvidenceRequest;
+    toAminoMsg(message: QueryEvidenceRequest): QueryEvidenceRequestAminoMsg;
+    fromProtoMsg(message: QueryEvidenceRequestProtoMsg): QueryEvidenceRequest;
+    toProto(message: QueryEvidenceRequest): Uint8Array;
+    toProtoMsg(message: QueryEvidenceRequest): QueryEvidenceRequestProtoMsg;
+};
+export declare const QueryEvidenceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryEvidenceResponse;
+    isAmino(o: any): o is QueryEvidenceResponseAmino;
+    encode(message: QueryEvidenceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryEvidenceResponse;
+    fromPartial(object: DeepPartial<QueryEvidenceResponse>): QueryEvidenceResponse;
+    fromAmino(object: QueryEvidenceResponseAmino): QueryEvidenceResponse;
+    toAmino(message: QueryEvidenceResponse): QueryEvidenceResponseAmino;
+    fromAminoMsg(object: QueryEvidenceResponseAminoMsg): QueryEvidenceResponse;
+    toAminoMsg(message: QueryEvidenceResponse): QueryEvidenceResponseAminoMsg;
+    fromProtoMsg(message: QueryEvidenceResponseProtoMsg): QueryEvidenceResponse;
+    toProto(message: QueryEvidenceResponse): Uint8Array;
+    toProtoMsg(message: QueryEvidenceResponse): QueryEvidenceResponseProtoMsg;
+};
+export declare const QueryAllEvidenceRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAllEvidenceRequest;
+    isAmino(o: any): o is QueryAllEvidenceRequestAmino;
+    encode(message: QueryAllEvidenceRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllEvidenceRequest;
+    fromPartial(object: DeepPartial<QueryAllEvidenceRequest>): QueryAllEvidenceRequest;
+    fromAmino(object: QueryAllEvidenceRequestAmino): QueryAllEvidenceRequest;
+    toAmino(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestAmino;
+    fromAminoMsg(object: QueryAllEvidenceRequestAminoMsg): QueryAllEvidenceRequest;
+    toAminoMsg(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestAminoMsg;
+    fromProtoMsg(message: QueryAllEvidenceRequestProtoMsg): QueryAllEvidenceRequest;
+    toProto(message: QueryAllEvidenceRequest): Uint8Array;
+    toProtoMsg(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestProtoMsg;
+};
+export declare const QueryAllEvidenceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAllEvidenceResponse;
+    isAmino(o: any): o is QueryAllEvidenceResponseAmino;
+    encode(message: QueryAllEvidenceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllEvidenceResponse;
+    fromPartial(object: DeepPartial<QueryAllEvidenceResponse>): QueryAllEvidenceResponse;
+    fromAmino(object: QueryAllEvidenceResponseAmino): QueryAllEvidenceResponse;
+    toAmino(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseAmino;
+    fromAminoMsg(object: QueryAllEvidenceResponseAminoMsg): QueryAllEvidenceResponse;
+    toAminoMsg(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseAminoMsg;
+    fromProtoMsg(message: QueryAllEvidenceResponseProtoMsg): QueryAllEvidenceResponse;
+    toProto(message: QueryAllEvidenceResponse): Uint8Array;
+    toProtoMsg(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseProtoMsg;
+};