@xpla/xplajs 1.7.0-beta.0

package/src/tendermint/types/validator.ts

@@ -0,0 +1,389 @@
+import { PublicKey, PublicKeyAmino } from "../crypto/keys";
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../helpers";
+import { GlobalDecoderRegistry } from "../../registry";
+/** BlockIdFlag indicates which BlockID the signature is for */
+export enum BlockIDFlag {
+  /** BLOCK_ID_FLAG_UNKNOWN - indicates an error condition */
+  BLOCK_ID_FLAG_UNKNOWN = 0,
+  /** BLOCK_ID_FLAG_ABSENT - the vote was not received */
+  BLOCK_ID_FLAG_ABSENT = 1,
+  BLOCK_ID_FLAG_COMMIT = 2,
+  /** BLOCK_ID_FLAG_NIL - voted for nil */
+  BLOCK_ID_FLAG_NIL = 3,
+  UNRECOGNIZED = -1,
+}
+export const BlockIDFlagAmino = BlockIDFlag;
+export function blockIDFlagFromJSON(object: any): BlockIDFlag {
+  switch (object) {
+    case 0:
+    case "BLOCK_ID_FLAG_UNKNOWN":
+      return BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN;
+    case 1:
+    case "BLOCK_ID_FLAG_ABSENT":
+      return BlockIDFlag.BLOCK_ID_FLAG_ABSENT;
+    case 2:
+    case "BLOCK_ID_FLAG_COMMIT":
+      return BlockIDFlag.BLOCK_ID_FLAG_COMMIT;
+    case 3:
+    case "BLOCK_ID_FLAG_NIL":
+      return BlockIDFlag.BLOCK_ID_FLAG_NIL;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return BlockIDFlag.UNRECOGNIZED;
+  }
+}
+export function blockIDFlagToJSON(object: BlockIDFlag): string {
+  switch (object) {
+    case BlockIDFlag.BLOCK_ID_FLAG_UNKNOWN:
+      return "BLOCK_ID_FLAG_UNKNOWN";
+    case BlockIDFlag.BLOCK_ID_FLAG_ABSENT:
+      return "BLOCK_ID_FLAG_ABSENT";
+    case BlockIDFlag.BLOCK_ID_FLAG_COMMIT:
+      return "BLOCK_ID_FLAG_COMMIT";
+    case BlockIDFlag.BLOCK_ID_FLAG_NIL:
+      return "BLOCK_ID_FLAG_NIL";
+    case BlockIDFlag.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+export interface ValidatorSet {
+  validators: Validator[];
+  proposer?: Validator;
+  totalVotingPower: bigint;
+}
+export interface ValidatorSetProtoMsg {
+  typeUrl: "/tendermint.types.ValidatorSet";
+  value: Uint8Array;
+}
+export interface ValidatorSetAmino {
+  validators: ValidatorAmino[];
+  proposer?: ValidatorAmino;
+  total_voting_power: string;
+}
+export interface ValidatorSetAminoMsg {
+  type: "/tendermint.types.ValidatorSet";
+  value: ValidatorSetAmino;
+}
+export interface Validator {
+  address: Uint8Array;
+  pubKey: PublicKey;
+  votingPower: bigint;
+  proposerPriority: bigint;
+}
+export interface ValidatorProtoMsg {
+  typeUrl: "/tendermint.types.Validator";
+  value: Uint8Array;
+}
+export interface ValidatorAmino {
+  address: string;
+  pub_key: PublicKeyAmino;
+  voting_power: string;
+  proposer_priority: string;
+}
+export interface ValidatorAminoMsg {
+  type: "/tendermint.types.Validator";
+  value: ValidatorAmino;
+}
+export interface SimpleValidator {
+  pubKey?: PublicKey;
+  votingPower: bigint;
+}
+export interface SimpleValidatorProtoMsg {
+  typeUrl: "/tendermint.types.SimpleValidator";
+  value: Uint8Array;
+}
+export interface SimpleValidatorAmino {
+  pub_key?: PublicKeyAmino;
+  voting_power: string;
+}
+export interface SimpleValidatorAminoMsg {
+  type: "/tendermint.types.SimpleValidator";
+  value: SimpleValidatorAmino;
+}
+function createBaseValidatorSet(): ValidatorSet {
+  return {
+    validators: [],
+    proposer: undefined,
+    totalVotingPower: BigInt(0)
+  };
+}
+export const ValidatorSet = {
+  typeUrl: "/tendermint.types.ValidatorSet",
+  is(o: any): o is ValidatorSet {
+    return o && (o.$typeUrl === ValidatorSet.typeUrl || Array.isArray(o.validators) && (!o.validators.length || Validator.is(o.validators[0])) && typeof o.totalVotingPower === "bigint");
+  },
+  isAmino(o: any): o is ValidatorSetAmino {
+    return o && (o.$typeUrl === ValidatorSet.typeUrl || Array.isArray(o.validators) && (!o.validators.length || Validator.isAmino(o.validators[0])) && typeof o.total_voting_power === "bigint");
+  },
+  encode(message: ValidatorSet, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.validators) {
+      Validator.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.proposer !== undefined) {
+      Validator.encode(message.proposer, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.totalVotingPower !== BigInt(0)) {
+      writer.uint32(24).int64(message.totalVotingPower);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ValidatorSet {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidatorSet();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.validators.push(Validator.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.proposer = Validator.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.totalVotingPower = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ValidatorSet>): ValidatorSet {
+    const message = createBaseValidatorSet();
+    message.validators = object.validators?.map(e => Validator.fromPartial(e)) || [];
+    message.proposer = object.proposer !== undefined && object.proposer !== null ? Validator.fromPartial(object.proposer) : undefined;
+    message.totalVotingPower = object.totalVotingPower !== undefined && object.totalVotingPower !== null ? BigInt(object.totalVotingPower.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ValidatorSetAmino): ValidatorSet {
+    const message = createBaseValidatorSet();
+    message.validators = object.validators?.map(e => Validator.fromAmino(e)) || [];
+    if (object.proposer !== undefined && object.proposer !== null) {
+      message.proposer = Validator.fromAmino(object.proposer);
+    }
+    if (object.total_voting_power !== undefined && object.total_voting_power !== null) {
+      message.totalVotingPower = BigInt(object.total_voting_power);
+    }
+    return message;
+  },
+  toAmino(message: ValidatorSet): ValidatorSetAmino {
+    const obj: any = {};
+    if (message.validators) {
+      obj.validators = message.validators.map(e => e ? Validator.toAmino(e) : undefined);
+    } else {
+      obj.validators = message.validators;
+    }
+    obj.proposer = message.proposer ? Validator.toAmino(message.proposer) : undefined;
+    obj.total_voting_power = message.totalVotingPower !== BigInt(0) ? message.totalVotingPower?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ValidatorSetAminoMsg): ValidatorSet {
+    return ValidatorSet.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ValidatorSetProtoMsg): ValidatorSet {
+    return ValidatorSet.decode(message.value);
+  },
+  toProto(message: ValidatorSet): Uint8Array {
+    return ValidatorSet.encode(message).finish();
+  },
+  toProtoMsg(message: ValidatorSet): ValidatorSetProtoMsg {
+    return {
+      typeUrl: "/tendermint.types.ValidatorSet",
+      value: ValidatorSet.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ValidatorSet.typeUrl, ValidatorSet);
+function createBaseValidator(): Validator {
+  return {
+    address: new Uint8Array(),
+    pubKey: PublicKey.fromPartial({}),
+    votingPower: BigInt(0),
+    proposerPriority: BigInt(0)
+  };
+}
+export const Validator = {
+  typeUrl: "/tendermint.types.Validator",
+  is(o: any): o is Validator {
+    return o && (o.$typeUrl === Validator.typeUrl || (o.address instanceof Uint8Array || typeof o.address === "string") && PublicKey.is(o.pubKey) && typeof o.votingPower === "bigint" && typeof o.proposerPriority === "bigint");
+  },
+  isAmino(o: any): o is ValidatorAmino {
+    return o && (o.$typeUrl === Validator.typeUrl || (o.address instanceof Uint8Array || typeof o.address === "string") && PublicKey.isAmino(o.pub_key) && typeof o.voting_power === "bigint" && typeof o.proposer_priority === "bigint");
+  },
+  encode(message: Validator, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address.length !== 0) {
+      writer.uint32(10).bytes(message.address);
+    }
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.votingPower !== BigInt(0)) {
+      writer.uint32(24).int64(message.votingPower);
+    }
+    if (message.proposerPriority !== BigInt(0)) {
+      writer.uint32(32).int64(message.proposerPriority);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Validator {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.bytes();
+          break;
+        case 2:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.votingPower = reader.int64();
+          break;
+        case 4:
+          message.proposerPriority = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Validator>): Validator {
+    const message = createBaseValidator();
+    message.address = object.address ?? new Uint8Array();
+    message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? PublicKey.fromPartial(object.pubKey) : undefined;
+    message.votingPower = object.votingPower !== undefined && object.votingPower !== null ? BigInt(object.votingPower.toString()) : BigInt(0);
+    message.proposerPriority = object.proposerPriority !== undefined && object.proposerPriority !== null ? BigInt(object.proposerPriority.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ValidatorAmino): Validator {
+    const message = createBaseValidator();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = bytesFromBase64(object.address);
+    }
+    if (object.pub_key !== undefined && object.pub_key !== null) {
+      message.pubKey = PublicKey.fromAmino(object.pub_key);
+    }
+    if (object.voting_power !== undefined && object.voting_power !== null) {
+      message.votingPower = BigInt(object.voting_power);
+    }
+    if (object.proposer_priority !== undefined && object.proposer_priority !== null) {
+      message.proposerPriority = BigInt(object.proposer_priority);
+    }
+    return message;
+  },
+  toAmino(message: Validator): ValidatorAmino {
+    const obj: any = {};
+    obj.address = message.address ? base64FromBytes(message.address) : undefined;
+    obj.pub_key = message.pubKey ? PublicKey.toAmino(message.pubKey) : undefined;
+    obj.voting_power = message.votingPower !== BigInt(0) ? message.votingPower?.toString() : undefined;
+    obj.proposer_priority = message.proposerPriority !== BigInt(0) ? message.proposerPriority?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ValidatorAminoMsg): Validator {
+    return Validator.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ValidatorProtoMsg): Validator {
+    return Validator.decode(message.value);
+  },
+  toProto(message: Validator): Uint8Array {
+    return Validator.encode(message).finish();
+  },
+  toProtoMsg(message: Validator): ValidatorProtoMsg {
+    return {
+      typeUrl: "/tendermint.types.Validator",
+      value: Validator.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Validator.typeUrl, Validator);
+function createBaseSimpleValidator(): SimpleValidator {
+  return {
+    pubKey: undefined,
+    votingPower: BigInt(0)
+  };
+}
+export const SimpleValidator = {
+  typeUrl: "/tendermint.types.SimpleValidator",
+  is(o: any): o is SimpleValidator {
+    return o && (o.$typeUrl === SimpleValidator.typeUrl || typeof o.votingPower === "bigint");
+  },
+  isAmino(o: any): o is SimpleValidatorAmino {
+    return o && (o.$typeUrl === SimpleValidator.typeUrl || typeof o.voting_power === "bigint");
+  },
+  encode(message: SimpleValidator, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.votingPower !== BigInt(0)) {
+      writer.uint32(16).int64(message.votingPower);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SimpleValidator {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimpleValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.votingPower = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<SimpleValidator>): SimpleValidator {
+    const message = createBaseSimpleValidator();
+    message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? PublicKey.fromPartial(object.pubKey) : undefined;
+    message.votingPower = object.votingPower !== undefined && object.votingPower !== null ? BigInt(object.votingPower.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: SimpleValidatorAmino): SimpleValidator {
+    const message = createBaseSimpleValidator();
+    if (object.pub_key !== undefined && object.pub_key !== null) {
+      message.pubKey = PublicKey.fromAmino(object.pub_key);
+    }
+    if (object.voting_power !== undefined && object.voting_power !== null) {
+      message.votingPower = BigInt(object.voting_power);
+    }
+    return message;
+  },
+  toAmino(message: SimpleValidator): SimpleValidatorAmino {
+    const obj: any = {};
+    obj.pub_key = message.pubKey ? PublicKey.toAmino(message.pubKey) : undefined;
+    obj.voting_power = message.votingPower !== BigInt(0) ? message.votingPower?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: SimpleValidatorAminoMsg): SimpleValidator {
+    return SimpleValidator.fromAmino(object.value);
+  },
+  fromProtoMsg(message: SimpleValidatorProtoMsg): SimpleValidator {
+    return SimpleValidator.decode(message.value);
+  },
+  toProto(message: SimpleValidator): Uint8Array {
+    return SimpleValidator.encode(message).finish();
+  },
+  toProtoMsg(message: SimpleValidator): SimpleValidatorProtoMsg {
+    return {
+      typeUrl: "/tendermint.types.SimpleValidator",
+      value: SimpleValidator.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(SimpleValidator.typeUrl, SimpleValidator);

package/src/tendermint/version/types.d.ts

@@ -0,0 +1,82 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+export interface App {
+    protocol: bigint;
+    software: string;
+}
+export interface AppProtoMsg {
+    typeUrl: "/tendermint.version.App";
+    value: Uint8Array;
+}
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+export interface AppAmino {
+    protocol: string;
+    software: string;
+}
+export interface AppAminoMsg {
+    type: "/tendermint.version.App";
+    value: AppAmino;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+export interface Consensus {
+    block: bigint;
+    app: bigint;
+}
+export interface ConsensusProtoMsg {
+    typeUrl: "/tendermint.version.Consensus";
+    value: Uint8Array;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+export interface ConsensusAmino {
+    block: string;
+    app: string;
+}
+export interface ConsensusAminoMsg {
+    type: "/tendermint.version.Consensus";
+    value: ConsensusAmino;
+}
+export declare const App: {
+    typeUrl: string;
+    is(o: any): o is App;
+    isAmino(o: any): o is AppAmino;
+    encode(message: App, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): App;
+    fromPartial(object: DeepPartial<App>): App;
+    fromAmino(object: AppAmino): App;
+    toAmino(message: App): AppAmino;
+    fromAminoMsg(object: AppAminoMsg): App;
+    fromProtoMsg(message: AppProtoMsg): App;
+    toProto(message: App): Uint8Array;
+    toProtoMsg(message: App): AppProtoMsg;
+};
+export declare const Consensus: {
+    typeUrl: string;
+    is(o: any): o is Consensus;
+    isAmino(o: any): o is ConsensusAmino;
+    encode(message: Consensus, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Consensus;
+    fromPartial(object: DeepPartial<Consensus>): Consensus;
+    fromAmino(object: ConsensusAmino): Consensus;
+    toAmino(message: Consensus): ConsensusAmino;
+    fromAminoMsg(object: ConsensusAminoMsg): Consensus;
+    fromProtoMsg(message: ConsensusProtoMsg): Consensus;
+    toProto(message: Consensus): Uint8Array;
+    toProtoMsg(message: Consensus): ConsensusProtoMsg;
+};

package/src/tendermint/version/types.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consensus = exports.App = void 0;
+const binary_1 = require("../../binary");
+const registry_1 = require("../../registry");
+function createBaseApp() {
+    return {
+        protocol: BigInt(0),
+        software: ""
+    };
+}
+exports.App = {
+    typeUrl: "/tendermint.version.App",
+    is(o) {
+        return o && (o.$typeUrl === exports.App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.App.typeUrl || typeof o.protocol === "bigint" && typeof o.software === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.protocol !== BigInt(0)) {
+            writer.uint32(8).uint64(message.protocol);
+        }
+        if (message.software !== "") {
+            writer.uint32(18).string(message.software);
+        }
+        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 = createBaseApp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.protocol = reader.uint64();
+                    break;
+                case 2:
+                    message.software = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseApp();
+        message.protocol = object.protocol !== undefined && object.protocol !== null ? BigInt(object.protocol.toString()) : BigInt(0);
+        message.software = object.software ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseApp();
+        if (object.protocol !== undefined && object.protocol !== null) {
+            message.protocol = BigInt(object.protocol);
+        }
+        if (object.software !== undefined && object.software !== null) {
+            message.software = object.software;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.protocol = message.protocol !== BigInt(0) ? message.protocol?.toString() : undefined;
+        obj.software = message.software === "" ? undefined : message.software;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.App.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.App.decode(message.value);
+    },
+    toProto(message) {
+        return exports.App.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/tendermint.version.App",
+            value: exports.App.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.App.typeUrl, exports.App);
+function createBaseConsensus() {
+    return {
+        block: BigInt(0),
+        app: BigInt(0)
+    };
+}
+exports.Consensus = {
+    typeUrl: "/tendermint.version.Consensus",
+    is(o) {
+        return o && (o.$typeUrl === exports.Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Consensus.typeUrl || typeof o.block === "bigint" && typeof o.app === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.block !== BigInt(0)) {
+            writer.uint32(8).uint64(message.block);
+        }
+        if (message.app !== BigInt(0)) {
+            writer.uint32(16).uint64(message.app);
+        }
+        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 = createBaseConsensus();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.block = reader.uint64();
+                    break;
+                case 2:
+                    message.app = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseConsensus();
+        message.block = object.block !== undefined && object.block !== null ? BigInt(object.block.toString()) : BigInt(0);
+        message.app = object.app !== undefined && object.app !== null ? BigInt(object.app.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseConsensus();
+        if (object.block !== undefined && object.block !== null) {
+            message.block = BigInt(object.block);
+        }
+        if (object.app !== undefined && object.app !== null) {
+            message.app = BigInt(object.app);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.block = message.block !== BigInt(0) ? message.block?.toString() : undefined;
+        obj.app = message.app !== BigInt(0) ? message.app?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Consensus.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Consensus.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Consensus.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/tendermint.version.Consensus",
+            value: exports.Consensus.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Consensus.typeUrl, exports.Consensus);