types: {
    BlockIDFlag: any;
    SignedMsgType: any;
    Block: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Block;
        encode(message: Block, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockAmino): Block;
        fromAminoMsg(object: BlockAminoMsg): Block;
        fromPartial(object: {
            data?: {
                txs?: Uint8Array[];
            };
            evidence?: {
                evidence?: {
                    duplicateVoteEvidence?: {
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                        validatorPower?: (...) | (...);
                        voteA?: (...) | (...);
                        voteB?: (...) | (...);
                    };
                    lightClientAttackEvidence?: {
                        byzantineValidators?: (...) | (...);
                        commonHeight?: (...) | (...);
                        conflictingBlock?: (...) | (...);
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                    };
                }[];
            };
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            lastCommit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            };
        }): Block;
        fromProtoMsg(message: BlockProtoMsg): Block;
        toAmino(message: Block): BlockAmino;
        toProto(message: Block): Uint8Array;
        toProtoMsg(message: Block): BlockProtoMsg;
    };
    BlockID: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockID;
        encode(message: BlockID, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockIDAmino): BlockID;
        fromAminoMsg(object: BlockIDAminoMsg): BlockID;
        fromPartial(object: {
            hash?: Uint8Array;
            partSetHeader?: {
                hash?: Uint8Array;
                total?: number;
            };
        }): BlockID;
        fromProtoMsg(message: BlockIDProtoMsg): BlockID;
        toAmino(message: BlockID): BlockIDAmino;
        toProto(message: BlockID): Uint8Array;
        toProtoMsg(message: BlockID): BlockIDProtoMsg;
    };
    BlockIDFlagAmino: typeof BlockIDFlag;
    BlockIDFlagSDKType: typeof BlockIDFlag;
    BlockMeta: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockMeta;
        encode(message: BlockMeta, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockMetaAmino): BlockMeta;
        fromAminoMsg(object: BlockMetaAminoMsg): BlockMeta;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            blockSize?: bigint;
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            numTxs?: bigint;
        }): BlockMeta;
        fromProtoMsg(message: BlockMetaProtoMsg): BlockMeta;
        toAmino(message: BlockMeta): BlockMetaAmino;
        toProto(message: BlockMeta): Uint8Array;
        toProtoMsg(message: BlockMeta): BlockMetaProtoMsg;
    };
    BlockParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockParams;
        encode(message: BlockParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockParamsAmino): BlockParams;
        fromAminoMsg(object: BlockParamsAminoMsg): BlockParams;
        fromPartial(object: {
            maxBytes?: bigint;
            maxGas?: bigint;
            timeIotaMs?: bigint;
        }): BlockParams;
        fromProtoMsg(message: BlockParamsProtoMsg): BlockParams;
        toAmino(message: BlockParams): BlockParamsAmino;
        toProto(message: BlockParams): Uint8Array;
        toProtoMsg(message: BlockParams): BlockParamsProtoMsg;
    };
    Commit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Commit;
        encode(message: Commit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommitAmino): Commit;
        fromAminoMsg(object: CommitAminoMsg): Commit;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            round?: number;
            signatures?: {
                blockIdFlag?: BlockIDFlag;
                signature?: Uint8Array;
                timestamp?: Date;
                validatorAddress?: Uint8Array;
            }[];
        }): Commit;
        fromProtoMsg(message: CommitProtoMsg): Commit;
        toAmino(message: Commit): CommitAmino;
        toProto(message: Commit): Uint8Array;
        toProtoMsg(message: Commit): CommitProtoMsg;
    };
    CommitSig: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CommitSig;
        encode(message: CommitSig, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommitSigAmino): CommitSig;
        fromAminoMsg(object: CommitSigAminoMsg): CommitSig;
        fromPartial(object: {
            blockIdFlag?: BlockIDFlag;
            signature?: Uint8Array;
            timestamp?: Date;
            validatorAddress?: Uint8Array;
        }): CommitSig;
        fromProtoMsg(message: CommitSigProtoMsg): CommitSig;
        toAmino(message: CommitSig): CommitSigAmino;
        toProto(message: CommitSig): Uint8Array;
        toProtoMsg(message: CommitSig): CommitSigProtoMsg;
    };
    ConsensusParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConsensusParams;
        encode(message: ConsensusParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConsensusParamsAmino): ConsensusParams;
        fromAminoMsg(object: ConsensusParamsAminoMsg): ConsensusParams;
        fromPartial(object: {
            block?: {
                maxBytes?: bigint;
                maxGas?: bigint;
                timeIotaMs?: bigint;
            };
            evidence?: {
                maxAgeDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                maxAgeNumBlocks?: bigint;
                maxBytes?: bigint;
            };
            validator?: {
                pubKeyTypes?: string[];
            };
            version?: {
                appVersion?: bigint;
            };
        }): ConsensusParams;
        fromProtoMsg(message: ConsensusParamsProtoMsg): ConsensusParams;
        toAmino(message: ConsensusParams): ConsensusParamsAmino;
        toProto(message: ConsensusParams): Uint8Array;
        toProtoMsg(message: ConsensusParams): ConsensusParamsProtoMsg;
    };
    Data: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Data;
        encode(message: Data, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DataAmino): Data;
        fromAminoMsg(object: DataAminoMsg): Data;
        fromPartial(object: {
            txs?: Uint8Array[];
        }): Data;
        fromProtoMsg(message: DataProtoMsg): Data;
        toAmino(message: Data): DataAmino;
        toProto(message: Data): Uint8Array;
        toProtoMsg(message: Data): DataProtoMsg;
    };
    DuplicateVoteEvidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DuplicateVoteEvidence;
        encode(message: DuplicateVoteEvidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DuplicateVoteEvidenceAmino): DuplicateVoteEvidence;
        fromAminoMsg(object: DuplicateVoteEvidenceAminoMsg): DuplicateVoteEvidence;
        fromPartial(object: {
            timestamp?: Date;
            totalVotingPower?: bigint;
            validatorPower?: bigint;
            voteA?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            };
            voteB?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            };
        }): DuplicateVoteEvidence;
        fromProtoMsg(message: DuplicateVoteEvidenceProtoMsg): DuplicateVoteEvidence;
        toAmino(message: DuplicateVoteEvidence): DuplicateVoteEvidenceAmino;
        toProto(message: DuplicateVoteEvidence): Uint8Array;
        toProtoMsg(message: DuplicateVoteEvidence): DuplicateVoteEvidenceProtoMsg;
    };
    Evidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Evidence;
        encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceAmino): Evidence;
        fromAminoMsg(object: EvidenceAminoMsg): Evidence;
        fromPartial(object: {
            duplicateVoteEvidence?: {
                timestamp?: Date;
                totalVotingPower?: bigint;
                validatorPower?: bigint;
                voteA?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
                voteB?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
            };
            lightClientAttackEvidence?: {
                byzantineValidators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
                commonHeight?: bigint;
                conflictingBlock?: {
                    signedHeader?: {
                        commit?: {
                            blockId?: ...;
                            height?: ...;
                            round?: ...;
                            signatures?: ...;
                        };
                        header?: {
                            appHash?: ...;
                            chainId?: ...;
                            consensusHash?: ...;
                            dataHash?: ...;
                            evidenceHash?: ...;
                            height?: ...;
                            lastBlockId?: ...;
                            lastCommitHash?: ...;
                            lastResultsHash?: ...;
                            nextValidatorsHash?: ...;
                            proposerAddress?: ...;
                            time?: ...;
                            validatorsHash?: ...;
                            version?: ...;
                        };
                    };
                    validatorSet?: {
                        proposer?: {
                            address?: ...;
                            proposerPriority?: ...;
                            pubKey?: ...;
                            votingPower?: ...;
                        };
                        totalVotingPower?: bigint;
                        validators?: (...)[];
                    };
                };
                timestamp?: Date;
                totalVotingPower?: bigint;
            };
        }): Evidence;
        fromProtoMsg(message: EvidenceProtoMsg): Evidence;
        toAmino(message: Evidence): EvidenceAmino;
        toProto(message: Evidence): Uint8Array;
        toProtoMsg(message: Evidence): EvidenceProtoMsg;
    };
    EvidenceList: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): EvidenceList;
        encode(message: EvidenceList, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceListAmino): EvidenceList;
        fromAminoMsg(object: EvidenceListAminoMsg): EvidenceList;
        fromPartial(object: {
            evidence?: {
                duplicateVoteEvidence?: {
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                    validatorPower?: bigint;
                    voteA?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                    voteB?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                };
                lightClientAttackEvidence?: {
                    byzantineValidators?: {
                        address?: ...;
                        proposerPriority?: ...;
                        pubKey?: ...;
                        votingPower?: ...;
                    }[];
                    commonHeight?: bigint;
                    conflictingBlock?: {
                        signedHeader?: (...) | (...);
                        validatorSet?: (...) | (...);
                    };
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                };
            }[];
        }): EvidenceList;
        fromProtoMsg(message: EvidenceListProtoMsg): EvidenceList;
        toAmino(message: EvidenceList): EvidenceListAmino;
        toProto(message: EvidenceList): Uint8Array;
        toProtoMsg(message: EvidenceList): EvidenceListProtoMsg;
    };
    EvidenceParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): EvidenceParams;
        encode(message: EvidenceParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceParamsAmino): EvidenceParams;
        fromAminoMsg(object: EvidenceParamsAminoMsg): EvidenceParams;
        fromPartial(object: {
            maxAgeDuration?: {
                nanos?: number;
                seconds?: bigint;
            };
            maxAgeNumBlocks?: bigint;
            maxBytes?: bigint;
        }): EvidenceParams;
        fromProtoMsg(message: EvidenceParamsProtoMsg): EvidenceParams;
        toAmino(message: EvidenceParams): EvidenceParamsAmino;
        toProto(message: EvidenceParams): Uint8Array;
        toProtoMsg(message: EvidenceParams): EvidenceParamsProtoMsg;
    };
    HashedParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): HashedParams;
        encode(message: HashedParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HashedParamsAmino): HashedParams;
        fromAminoMsg(object: HashedParamsAminoMsg): HashedParams;
        fromPartial(object: {
            blockMaxBytes?: bigint;
            blockMaxGas?: bigint;
        }): HashedParams;
        fromProtoMsg(message: HashedParamsProtoMsg): HashedParams;
        toAmino(message: HashedParams): HashedParamsAmino;
        toProto(message: HashedParams): Uint8Array;
        toProtoMsg(message: HashedParams): HashedParamsProtoMsg;
    };
    Header: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Header;
        encode(message: Header, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HeaderAmino): Header;
        fromAminoMsg(object: HeaderAminoMsg): Header;
        fromPartial(object: {
            appHash?: Uint8Array;
            chainId?: string;
            consensusHash?: Uint8Array;
            dataHash?: Uint8Array;
            evidenceHash?: Uint8Array;
            height?: bigint;
            lastBlockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            lastCommitHash?: Uint8Array;
            lastResultsHash?: Uint8Array;
            nextValidatorsHash?: Uint8Array;
            proposerAddress?: Uint8Array;
            time?: Date;
            validatorsHash?: Uint8Array;
            version?: {
                app?: bigint;
                block?: bigint;
            };
        }): Header;
        fromProtoMsg(message: HeaderProtoMsg): Header;
        toAmino(message: Header): HeaderAmino;
        toProto(message: Header): Uint8Array;
        toProtoMsg(message: Header): HeaderProtoMsg;
    };
    LightBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LightBlock;
        encode(message: LightBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LightBlockAmino): LightBlock;
        fromAminoMsg(object: LightBlockAminoMsg): LightBlock;
        fromPartial(object: {
            signedHeader?: {
                commit?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signatures?: {
                        blockIdFlag?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        validatorAddress?: (...) | (...);
                    }[];
                };
                header?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: bigint;
                        block?: bigint;
                    };
                };
            };
            validatorSet?: {
                proposer?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    };
                    votingPower?: bigint;
                };
                totalVotingPower?: bigint;
                validators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
            };
        }): LightBlock;
        fromProtoMsg(message: LightBlockProtoMsg): LightBlock;
        toAmino(message: LightBlock): LightBlockAmino;
        toProto(message: LightBlock): Uint8Array;
        toProtoMsg(message: LightBlock): LightBlockProtoMsg;
    };
    LightClientAttackEvidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LightClientAttackEvidence;
        encode(message: LightClientAttackEvidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LightClientAttackEvidenceAmino): LightClientAttackEvidence;
        fromAminoMsg(object: LightClientAttackEvidenceAminoMsg): LightClientAttackEvidence;
        fromPartial(object: {
            byzantineValidators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[];
            commonHeight?: bigint;
            conflictingBlock?: {
                signedHeader?: {
                    commit?: {
                        blockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        height?: bigint;
                        round?: number;
                        signatures?: (...)[];
                    };
                    header?: {
                        appHash?: Uint8Array;
                        chainId?: string;
                        consensusHash?: Uint8Array;
                        dataHash?: Uint8Array;
                        evidenceHash?: Uint8Array;
                        height?: bigint;
                        lastBlockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        lastCommitHash?: Uint8Array;
                        lastResultsHash?: Uint8Array;
                        nextValidatorsHash?: Uint8Array;
                        proposerAddress?: Uint8Array;
                        time?: Date;
                        validatorsHash?: Uint8Array;
                        version?: {
                            app?: ...;
                            block?: ...;
                        };
                    };
                };
                validatorSet?: {
                    proposer?: {
                        address?: Uint8Array;
                        proposerPriority?: bigint;
                        pubKey?: {
                            ed25519?: ...;
                            secp256k1?: ...;
                        };
                        votingPower?: bigint;
                    };
                    totalVotingPower?: bigint;
                    validators?: {
                        address?: (...) | (...);
                        proposerPriority?: (...) | (...);
                        pubKey?: (...) | (...);
                        votingPower?: (...) | (...);
                    }[];
                };
            };
            timestamp?: Date;
            totalVotingPower?: bigint;
        }): LightClientAttackEvidence;
        fromProtoMsg(message: LightClientAttackEvidenceProtoMsg): LightClientAttackEvidence;
        toAmino(message: LightClientAttackEvidence): LightClientAttackEvidenceAmino;
        toProto(message: LightClientAttackEvidence): Uint8Array;
        toProtoMsg(message: LightClientAttackEvidence): LightClientAttackEvidenceProtoMsg;
    };
    Part: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Part;
        encode(message: Part, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PartAmino): Part;
        fromAminoMsg(object: PartAminoMsg): Part;
        fromPartial(object: {
            bytes?: Uint8Array;
            index?: number;
            proof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            };
        }): Part;
        fromProtoMsg(message: PartProtoMsg): Part;
        toAmino(message: Part): PartAmino;
        toProto(message: Part): Uint8Array;
        toProtoMsg(message: Part): PartProtoMsg;
    };
    PartSetHeader: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PartSetHeader;
        encode(message: PartSetHeader, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PartSetHeaderAmino): PartSetHeader;
        fromAminoMsg(object: PartSetHeaderAminoMsg): PartSetHeader;
        fromPartial(object: {
            hash?: Uint8Array;
            total?: number;
        }): PartSetHeader;
        fromProtoMsg(message: PartSetHeaderProtoMsg): PartSetHeader;
        toAmino(message: PartSetHeader): PartSetHeaderAmino;
        toProto(message: PartSetHeader): Uint8Array;
        toProtoMsg(message: PartSetHeader): PartSetHeaderProtoMsg;
    };
    Proposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Proposal;
        encode(message: Proposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ProposalAmino): Proposal;
        fromAminoMsg(object: ProposalAminoMsg): Proposal;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            polRound?: number;
            round?: number;
            signature?: Uint8Array;
            timestamp?: Date;
            type?: SignedMsgType;
        }): Proposal;
        fromProtoMsg(message: ProposalProtoMsg): Proposal;
        toAmino(message: Proposal): ProposalAmino;
        toProto(message: Proposal): Uint8Array;
        toProtoMsg(message: Proposal): ProposalProtoMsg;
    };
    SignedHeader: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SignedHeader;
        encode(message: SignedHeader, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SignedHeaderAmino): SignedHeader;
        fromAminoMsg(object: SignedHeaderAminoMsg): SignedHeader;
        fromPartial(object: {
            commit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            };
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
        }): SignedHeader;
        fromProtoMsg(message: SignedHeaderProtoMsg): SignedHeader;
        toAmino(message: SignedHeader): SignedHeaderAmino;
        toProto(message: SignedHeader): Uint8Array;
        toProtoMsg(message: SignedHeader): SignedHeaderProtoMsg;
    };
    SignedMsgTypeAmino: typeof SignedMsgType;
    SignedMsgTypeSDKType: typeof SignedMsgType;
    SimpleValidator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SimpleValidator;
        encode(message: SimpleValidator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SimpleValidatorAmino): SimpleValidator;
        fromAminoMsg(object: SimpleValidatorAminoMsg): SimpleValidator;
        fromPartial(object: {
            pubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            };
            votingPower?: bigint;
        }): SimpleValidator;
        fromProtoMsg(message: SimpleValidatorProtoMsg): SimpleValidator;
        toAmino(message: SimpleValidator): SimpleValidatorAmino;
        toProto(message: SimpleValidator): Uint8Array;
        toProtoMsg(message: SimpleValidator): SimpleValidatorProtoMsg;
    };
    TxProof: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TxProof;
        encode(message: TxProof, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TxProofAmino): TxProof;
        fromAminoMsg(object: TxProofAminoMsg): TxProof;
        fromPartial(object: {
            data?: Uint8Array;
            proof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            };
            rootHash?: Uint8Array;
        }): TxProof;
        fromProtoMsg(message: TxProofProtoMsg): TxProof;
        toAmino(message: TxProof): TxProofAmino;
        toProto(message: TxProof): Uint8Array;
        toProtoMsg(message: TxProof): TxProofProtoMsg;
    };
    Validator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Validator;
        encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorAmino): Validator;
        fromAminoMsg(object: ValidatorAminoMsg): Validator;
        fromPartial(object: {
            address?: Uint8Array;
            proposerPriority?: bigint;
            pubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            };
            votingPower?: bigint;
        }): Validator;
        fromProtoMsg(message: ValidatorProtoMsg): Validator;
        toAmino(message: Validator): ValidatorAmino;
        toProto(message: Validator): Uint8Array;
        toProtoMsg(message: Validator): ValidatorProtoMsg;
    };
    ValidatorParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValidatorParams;
        encode(message: ValidatorParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorParamsAmino): ValidatorParams;
        fromAminoMsg(object: ValidatorParamsAminoMsg): ValidatorParams;
        fromPartial(object: {
            pubKeyTypes?: string[];
        }): ValidatorParams;
        fromProtoMsg(message: ValidatorParamsProtoMsg): ValidatorParams;
        toAmino(message: ValidatorParams): ValidatorParamsAmino;
        toProto(message: ValidatorParams): Uint8Array;
        toProtoMsg(message: ValidatorParams): ValidatorParamsProtoMsg;
    };
    ValidatorSet: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValidatorSet;
        encode(message: ValidatorSet, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorSetAmino): ValidatorSet;
        fromAminoMsg(object: ValidatorSetAminoMsg): ValidatorSet;
        fromPartial(object: {
            proposer?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            };
            totalVotingPower?: bigint;
            validators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[];
        }): ValidatorSet;
        fromProtoMsg(message: ValidatorSetProtoMsg): ValidatorSet;
        toAmino(message: ValidatorSet): ValidatorSetAmino;
        toProto(message: ValidatorSet): Uint8Array;
        toProtoMsg(message: ValidatorSet): ValidatorSetProtoMsg;
    };
    VersionParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): VersionParams;
        encode(message: VersionParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VersionParamsAmino): VersionParams;
        fromAminoMsg(object: VersionParamsAminoMsg): VersionParams;
        fromPartial(object: {
            appVersion?: bigint;
        }): VersionParams;
        fromProtoMsg(message: VersionParamsProtoMsg): VersionParams;
        toAmino(message: VersionParams): VersionParamsAmino;
        toProto(message: VersionParams): Uint8Array;
        toProtoMsg(message: VersionParams): VersionParamsProtoMsg;
    };
    Vote: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Vote;
        encode(message: Vote, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VoteAmino): Vote;
        fromAminoMsg(object: VoteAminoMsg): Vote;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            round?: number;
            signature?: Uint8Array;
            timestamp?: Date;
            type?: SignedMsgType;
            validatorAddress?: Uint8Array;
            validatorIndex?: number;
        }): Vote;
        fromProtoMsg(message: VoteProtoMsg): Vote;
        toAmino(message: Vote): VoteAmino;
        toProto(message: Vote): Uint8Array;
        toProtoMsg(message: Vote): VoteProtoMsg;
    };
    blockIDFlagFromJSON(object: any): BlockIDFlag;
    blockIDFlagToJSON(object: BlockIDFlag): string;
    signedMsgTypeFromJSON(object: any): SignedMsgType;
    signedMsgTypeToJSON(object: SignedMsgType): string;
} = ...

Type declaration

  • Block: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Block;
        encode(message: Block, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockAmino): Block;
        fromAminoMsg(object: BlockAminoMsg): Block;
        fromPartial(object: {
            data?: {
                txs?: Uint8Array[];
            };
            evidence?: {
                evidence?: {
                    duplicateVoteEvidence?: {
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                        validatorPower?: (...) | (...);
                        voteA?: (...) | (...);
                        voteB?: (...) | (...);
                    };
                    lightClientAttackEvidence?: {
                        byzantineValidators?: (...) | (...);
                        commonHeight?: (...) | (...);
                        conflictingBlock?: (...) | (...);
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                    };
                }[];
            };
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            lastCommit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            };
        }): Block;
        fromProtoMsg(message: BlockProtoMsg): Block;
        toAmino(message: Block): BlockAmino;
        toProto(message: Block): Uint8Array;
        toProtoMsg(message: Block): BlockProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Block

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Block

    • fromAminoMsg:function
      • Parameters

        Returns Block

    • fromPartial:function
      • Parameters

        • object: {
              data?: {
                  txs?: Uint8Array[];
              };
              evidence?: {
                  evidence?: {
                      duplicateVoteEvidence?: {
                          timestamp?: (...) | (...);
                          totalVotingPower?: (...) | (...);
                          validatorPower?: (...) | (...);
                          voteA?: (...) | (...);
                          voteB?: (...) | (...);
                      };
                      lightClientAttackEvidence?: {
                          byzantineValidators?: (...) | (...);
                          commonHeight?: (...) | (...);
                          conflictingBlock?: (...) | (...);
                          timestamp?: (...) | (...);
                          totalVotingPower?: (...) | (...);
                      };
                  }[];
              };
              header?: {
                  appHash?: Uint8Array;
                  chainId?: string;
                  consensusHash?: Uint8Array;
                  dataHash?: Uint8Array;
                  evidenceHash?: Uint8Array;
                  height?: bigint;
                  lastBlockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  lastCommitHash?: Uint8Array;
                  lastResultsHash?: Uint8Array;
                  nextValidatorsHash?: Uint8Array;
                  proposerAddress?: Uint8Array;
                  time?: Date;
                  validatorsHash?: Uint8Array;
                  version?: {
                      app?: bigint;
                      block?: bigint;
                  };
              };
              lastCommit?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signatures?: {
                      blockIdFlag?: BlockIDFlag;
                      signature?: Uint8Array;
                      timestamp?: Date;
                      validatorAddress?: Uint8Array;
                  }[];
              };
          }
          • Optionaldata?: {
                txs?: Uint8Array[];
            }
            • Optionaltxs?: Uint8Array[]

              Txs that will be applied by state @ block.Height+1. NOTE: not all txs here are valid. We're just agreeing on the order first. This means that block.AppHash does not include these txs.

          • Optionalevidence?: {
                evidence?: {
                    duplicateVoteEvidence?: {
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                        validatorPower?: (...) | (...);
                        voteA?: (...) | (...);
                        voteB?: (...) | (...);
                    };
                    lightClientAttackEvidence?: {
                        byzantineValidators?: (...) | (...);
                        commonHeight?: (...) | (...);
                        conflictingBlock?: (...) | (...);
                        timestamp?: (...) | (...);
                        totalVotingPower?: (...) | (...);
                    };
                }[];
            }
            • Optionalevidence?: {
                  duplicateVoteEvidence?: {
                      timestamp?: (...) | (...);
                      totalVotingPower?: (...) | (...);
                      validatorPower?: (...) | (...);
                      voteA?: (...) | (...);
                      voteB?: (...) | (...);
                  };
                  lightClientAttackEvidence?: {
                      byzantineValidators?: (...) | (...);
                      commonHeight?: (...) | (...);
                      conflictingBlock?: (...) | (...);
                      timestamp?: (...) | (...);
                      totalVotingPower?: (...) | (...);
                  };
              }[]
          • Optionalheader?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            }
            • OptionalappHash?: Uint8Array

              state after txs from the previous block

            • OptionalchainId?: string
            • OptionalconsensusHash?: Uint8Array

              consensus params for current block

            • OptionaldataHash?: Uint8Array
            • OptionalevidenceHash?: Uint8Array

              consensus info

            • Optionalheight?: bigint
            • OptionallastBlockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }

              prev block info

              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • OptionallastCommitHash?: Uint8Array

              hashes of block data

            • OptionallastResultsHash?: Uint8Array
            • OptionalnextValidatorsHash?: Uint8Array

              validators for the next block

            • OptionalproposerAddress?: Uint8Array

              original proposer of the block

            • Optionaltime?: Date
            • OptionalvalidatorsHash?: Uint8Array

              hashes from the app output from the prev block

            • Optionalversion?: {
                  app?: bigint;
                  block?: bigint;
              }

              basic block info

              • Optionalapp?: bigint
              • Optionalblock?: bigint
          • OptionallastCommit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            }
            • OptionalblockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }
              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • Optionalheight?: bigint
            • Optionalround?: number
            • Optionalsignatures?: {
                  blockIdFlag?: BlockIDFlag;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  validatorAddress?: Uint8Array;
              }[]

        Returns Block

    • fromProtoMsg:function
      • Parameters

        Returns Block

    • toAmino:function
      • Parameters

        Returns BlockAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • BlockID: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockID;
        encode(message: BlockID, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockIDAmino): BlockID;
        fromAminoMsg(object: BlockIDAminoMsg): BlockID;
        fromPartial(object: {
            hash?: Uint8Array;
            partSetHeader?: {
                hash?: Uint8Array;
                total?: number;
            };
        }): BlockID;
        fromProtoMsg(message: BlockIDProtoMsg): BlockID;
        toAmino(message: BlockID): BlockIDAmino;
        toProto(message: BlockID): Uint8Array;
        toProtoMsg(message: BlockID): BlockIDProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns BlockID

    • encode:function
    • fromAmino:function
      • Parameters

        Returns BlockID

    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              hash?: Uint8Array;
              partSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              };
          }
          • Optionalhash?: Uint8Array
          • OptionalpartSetHeader?: {
                hash?: Uint8Array;
                total?: number;
            }
            • Optionalhash?: Uint8Array
            • Optionaltotal?: number

        Returns BlockID

    • fromProtoMsg:function
      • Parameters

        Returns BlockID

    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • BlockIDFlagAmino: typeof BlockIDFlag
  • BlockIDFlagSDKType: typeof BlockIDFlag
  • BlockMeta: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockMeta;
        encode(message: BlockMeta, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockMetaAmino): BlockMeta;
        fromAminoMsg(object: BlockMetaAminoMsg): BlockMeta;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            blockSize?: bigint;
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            numTxs?: bigint;
        }): BlockMeta;
        fromProtoMsg(message: BlockMetaProtoMsg): BlockMeta;
        toAmino(message: BlockMeta): BlockMetaAmino;
        toProto(message: BlockMeta): Uint8Array;
        toProtoMsg(message: BlockMeta): BlockMetaProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns BlockMeta

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              blockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              };
              blockSize?: bigint;
              header?: {
                  appHash?: Uint8Array;
                  chainId?: string;
                  consensusHash?: Uint8Array;
                  dataHash?: Uint8Array;
                  evidenceHash?: Uint8Array;
                  height?: bigint;
                  lastBlockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  lastCommitHash?: Uint8Array;
                  lastResultsHash?: Uint8Array;
                  nextValidatorsHash?: Uint8Array;
                  proposerAddress?: Uint8Array;
                  time?: Date;
                  validatorsHash?: Uint8Array;
                  version?: {
                      app?: bigint;
                      block?: bigint;
                  };
              };
              numTxs?: bigint;
          }
          • OptionalblockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            }
            • Optionalhash?: Uint8Array
            • OptionalpartSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              }
              • Optionalhash?: Uint8Array
              • Optionaltotal?: number
          • OptionalblockSize?: bigint
          • Optionalheader?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            }
            • OptionalappHash?: Uint8Array

              state after txs from the previous block

            • OptionalchainId?: string
            • OptionalconsensusHash?: Uint8Array

              consensus params for current block

            • OptionaldataHash?: Uint8Array
            • OptionalevidenceHash?: Uint8Array

              consensus info

            • Optionalheight?: bigint
            • OptionallastBlockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }

              prev block info

              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • OptionallastCommitHash?: Uint8Array

              hashes of block data

            • OptionallastResultsHash?: Uint8Array
            • OptionalnextValidatorsHash?: Uint8Array

              validators for the next block

            • OptionalproposerAddress?: Uint8Array

              original proposer of the block

            • Optionaltime?: Date
            • OptionalvalidatorsHash?: Uint8Array

              hashes from the app output from the prev block

            • Optionalversion?: {
                  app?: bigint;
                  block?: bigint;
              }

              basic block info

              • Optionalapp?: bigint
              • Optionalblock?: bigint
          • OptionalnumTxs?: bigint

        Returns BlockMeta

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • BlockParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockParams;
        encode(message: BlockParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockParamsAmino): BlockParams;
        fromAminoMsg(object: BlockParamsAminoMsg): BlockParams;
        fromPartial(object: {
            maxBytes?: bigint;
            maxGas?: bigint;
            timeIotaMs?: bigint;
        }): BlockParams;
        fromProtoMsg(message: BlockParamsProtoMsg): BlockParams;
        toAmino(message: BlockParams): BlockParamsAmino;
        toProto(message: BlockParams): Uint8Array;
        toProtoMsg(message: BlockParams): BlockParamsProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns BlockParams

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              maxBytes?: bigint;
              maxGas?: bigint;
              timeIotaMs?: bigint;
          }
          • OptionalmaxBytes?: bigint

            Max block size, in bytes. Note: must be greater than 0

          • OptionalmaxGas?: bigint

            Max gas per block. Note: must be greater or equal to -1

          • OptionaltimeIotaMs?: bigint

            Minimum time increment between consecutive blocks (in milliseconds) If the block header timestamp is ahead of the system clock, decrease this value.

            Not exposed to the application.

        Returns BlockParams

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Commit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Commit;
        encode(message: Commit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommitAmino): Commit;
        fromAminoMsg(object: CommitAminoMsg): Commit;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            round?: number;
            signatures?: {
                blockIdFlag?: BlockIDFlag;
                signature?: Uint8Array;
                timestamp?: Date;
                validatorAddress?: Uint8Array;
            }[];
        }): Commit;
        fromProtoMsg(message: CommitProtoMsg): Commit;
        toAmino(message: Commit): CommitAmino;
        toProto(message: Commit): Uint8Array;
        toProtoMsg(message: Commit): CommitProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Commit

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Commit

    • fromAminoMsg:function
      • Parameters

        Returns Commit

    • fromPartial:function
      • Parameters

        • object: {
              blockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              };
              height?: bigint;
              round?: number;
              signatures?: {
                  blockIdFlag?: BlockIDFlag;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  validatorAddress?: Uint8Array;
              }[];
          }
          • OptionalblockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            }
            • Optionalhash?: Uint8Array
            • OptionalpartSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              }
              • Optionalhash?: Uint8Array
              • Optionaltotal?: number
          • Optionalheight?: bigint
          • Optionalround?: number
          • Optionalsignatures?: {
                blockIdFlag?: BlockIDFlag;
                signature?: Uint8Array;
                timestamp?: Date;
                validatorAddress?: Uint8Array;
            }[]

        Returns Commit

    • fromProtoMsg:function
      • Parameters

        Returns Commit

    • toAmino:function
      • Parameters

        Returns CommitAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • CommitSig: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CommitSig;
        encode(message: CommitSig, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommitSigAmino): CommitSig;
        fromAminoMsg(object: CommitSigAminoMsg): CommitSig;
        fromPartial(object: {
            blockIdFlag?: BlockIDFlag;
            signature?: Uint8Array;
            timestamp?: Date;
            validatorAddress?: Uint8Array;
        }): CommitSig;
        fromProtoMsg(message: CommitSigProtoMsg): CommitSig;
        toAmino(message: CommitSig): CommitSigAmino;
        toProto(message: CommitSig): Uint8Array;
        toProtoMsg(message: CommitSig): CommitSigProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns CommitSig

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              blockIdFlag?: BlockIDFlag;
              signature?: Uint8Array;
              timestamp?: Date;
              validatorAddress?: Uint8Array;
          }
          • OptionalblockIdFlag?: BlockIDFlag
          • Optionalsignature?: Uint8Array
          • Optionaltimestamp?: Date
          • OptionalvalidatorAddress?: Uint8Array

        Returns CommitSig

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • ConsensusParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConsensusParams;
        encode(message: ConsensusParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConsensusParamsAmino): ConsensusParams;
        fromAminoMsg(object: ConsensusParamsAminoMsg): ConsensusParams;
        fromPartial(object: {
            block?: {
                maxBytes?: bigint;
                maxGas?: bigint;
                timeIotaMs?: bigint;
            };
            evidence?: {
                maxAgeDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                maxAgeNumBlocks?: bigint;
                maxBytes?: bigint;
            };
            validator?: {
                pubKeyTypes?: string[];
            };
            version?: {
                appVersion?: bigint;
            };
        }): ConsensusParams;
        fromProtoMsg(message: ConsensusParamsProtoMsg): ConsensusParams;
        toAmino(message: ConsensusParams): ConsensusParamsAmino;
        toProto(message: ConsensusParams): Uint8Array;
        toProtoMsg(message: ConsensusParams): ConsensusParamsProtoMsg;
    }
    • typeUrl: string
    • decode:function
    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              block?: {
                  maxBytes?: bigint;
                  maxGas?: bigint;
                  timeIotaMs?: bigint;
              };
              evidence?: {
                  maxAgeDuration?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  maxAgeNumBlocks?: bigint;
                  maxBytes?: bigint;
              };
              validator?: {
                  pubKeyTypes?: string[];
              };
              version?: {
                  appVersion?: bigint;
              };
          }
          • Optionalblock?: {
                maxBytes?: bigint;
                maxGas?: bigint;
                timeIotaMs?: bigint;
            }
            • OptionalmaxBytes?: bigint

              Max block size, in bytes. Note: must be greater than 0

            • OptionalmaxGas?: bigint

              Max gas per block. Note: must be greater or equal to -1

            • OptionaltimeIotaMs?: bigint

              Minimum time increment between consecutive blocks (in milliseconds) If the block header timestamp is ahead of the system clock, decrease this value.

              Not exposed to the application.

          • Optionalevidence?: {
                maxAgeDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                maxAgeNumBlocks?: bigint;
                maxBytes?: bigint;
            }
            • OptionalmaxAgeDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              }

              Max age of evidence, in time.

              It should correspond with an app's "unbonding period" or other similar mechanism for handling Nothing-At-Stake attacks.

              • Optionalnanos?: number

                Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

              • Optionalseconds?: bigint

                Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

            • OptionalmaxAgeNumBlocks?: bigint

              Max age of evidence, in blocks.

              The basic formula for calculating this is: MaxAgeDuration / {average block time}.

            • OptionalmaxBytes?: bigint

              This sets the maximum size of total evidence in bytes that can be committed in a single block. and should fall comfortably under the max block bytes. Default is 1048576 or 1MB

          • Optionalvalidator?: {
                pubKeyTypes?: string[];
            }
            • OptionalpubKeyTypes?: string[]
          • Optionalversion?: {
                appVersion?: bigint;
            }
            • OptionalappVersion?: bigint

        Returns ConsensusParams

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Data: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Data;
        encode(message: Data, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DataAmino): Data;
        fromAminoMsg(object: DataAminoMsg): Data;
        fromPartial(object: {
            txs?: Uint8Array[];
        }): Data;
        fromProtoMsg(message: DataProtoMsg): Data;
        toAmino(message: Data): DataAmino;
        toProto(message: Data): Uint8Array;
        toProtoMsg(message: Data): DataProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Data

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Data

    • fromAminoMsg:function
      • Parameters

        Returns Data

    • fromPartial:function
      • Parameters

        • object: {
              txs?: Uint8Array[];
          }
          • Optionaltxs?: Uint8Array[]

            Txs that will be applied by state @ block.Height+1. NOTE: not all txs here are valid. We're just agreeing on the order first. This means that block.AppHash does not include these txs.

        Returns Data

    • fromProtoMsg:function
      • Parameters

        Returns Data

    • toAmino:function
      • Parameters

        Returns DataAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
      • Parameters

        Returns DataProtoMsg

  • DuplicateVoteEvidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DuplicateVoteEvidence;
        encode(message: DuplicateVoteEvidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DuplicateVoteEvidenceAmino): DuplicateVoteEvidence;
        fromAminoMsg(object: DuplicateVoteEvidenceAminoMsg): DuplicateVoteEvidence;
        fromPartial(object: {
            timestamp?: Date;
            totalVotingPower?: bigint;
            validatorPower?: bigint;
            voteA?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            };
            voteB?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            };
        }): DuplicateVoteEvidence;
        fromProtoMsg(message: DuplicateVoteEvidenceProtoMsg): DuplicateVoteEvidence;
        toAmino(message: DuplicateVoteEvidence): DuplicateVoteEvidenceAmino;
        toProto(message: DuplicateVoteEvidence): Uint8Array;
        toProtoMsg(message: DuplicateVoteEvidence): DuplicateVoteEvidenceProtoMsg;
    }
    • typeUrl: string
    • decode:function
    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              timestamp?: Date;
              totalVotingPower?: bigint;
              validatorPower?: bigint;
              voteA?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  type?: SignedMsgType;
                  validatorAddress?: Uint8Array;
                  validatorIndex?: number;
              };
              voteB?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  type?: SignedMsgType;
                  validatorAddress?: Uint8Array;
                  validatorIndex?: number;
              };
          }
          • Optionaltimestamp?: Date
          • OptionaltotalVotingPower?: bigint
          • OptionalvalidatorPower?: bigint
          • OptionalvoteA?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            }
            • OptionalblockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }

              zero if vote is nil.

              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • Optionalheight?: bigint
            • Optionalround?: number
            • Optionalsignature?: Uint8Array
            • Optionaltimestamp?: Date
            • Optionaltype?: SignedMsgType
            • OptionalvalidatorAddress?: Uint8Array
            • OptionalvalidatorIndex?: number
          • OptionalvoteB?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signature?: Uint8Array;
                timestamp?: Date;
                type?: SignedMsgType;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
            }
            • OptionalblockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }

              zero if vote is nil.

              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • Optionalheight?: bigint
            • Optionalround?: number
            • Optionalsignature?: Uint8Array
            • Optionaltimestamp?: Date
            • Optionaltype?: SignedMsgType
            • OptionalvalidatorAddress?: Uint8Array
            • OptionalvalidatorIndex?: number

        Returns DuplicateVoteEvidence

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Evidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Evidence;
        encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceAmino): Evidence;
        fromAminoMsg(object: EvidenceAminoMsg): Evidence;
        fromPartial(object: {
            duplicateVoteEvidence?: {
                timestamp?: Date;
                totalVotingPower?: bigint;
                validatorPower?: bigint;
                voteA?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
                voteB?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
            };
            lightClientAttackEvidence?: {
                byzantineValidators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
                commonHeight?: bigint;
                conflictingBlock?: {
                    signedHeader?: {
                        commit?: {
                            blockId?: ...;
                            height?: ...;
                            round?: ...;
                            signatures?: ...;
                        };
                        header?: {
                            appHash?: ...;
                            chainId?: ...;
                            consensusHash?: ...;
                            dataHash?: ...;
                            evidenceHash?: ...;
                            height?: ...;
                            lastBlockId?: ...;
                            lastCommitHash?: ...;
                            lastResultsHash?: ...;
                            nextValidatorsHash?: ...;
                            proposerAddress?: ...;
                            time?: ...;
                            validatorsHash?: ...;
                            version?: ...;
                        };
                    };
                    validatorSet?: {
                        proposer?: {
                            address?: ...;
                            proposerPriority?: ...;
                            pubKey?: ...;
                            votingPower?: ...;
                        };
                        totalVotingPower?: bigint;
                        validators?: (...)[];
                    };
                };
                timestamp?: Date;
                totalVotingPower?: bigint;
            };
        }): Evidence;
        fromProtoMsg(message: EvidenceProtoMsg): Evidence;
        toAmino(message: Evidence): EvidenceAmino;
        toProto(message: Evidence): Uint8Array;
        toProtoMsg(message: Evidence): EvidenceProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Evidence

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              duplicateVoteEvidence?: {
                  timestamp?: Date;
                  totalVotingPower?: bigint;
                  validatorPower?: bigint;
                  voteA?: {
                      blockId?: {
                          hash?: Uint8Array;
                          partSetHeader?: {
                              hash?: ...;
                              total?: ...;
                          };
                      };
                      height?: bigint;
                      round?: number;
                      signature?: Uint8Array;
                      timestamp?: Date;
                      type?: SignedMsgType;
                      validatorAddress?: Uint8Array;
                      validatorIndex?: number;
                  };
                  voteB?: {
                      blockId?: {
                          hash?: Uint8Array;
                          partSetHeader?: {
                              hash?: ...;
                              total?: ...;
                          };
                      };
                      height?: bigint;
                      round?: number;
                      signature?: Uint8Array;
                      timestamp?: Date;
                      type?: SignedMsgType;
                      validatorAddress?: Uint8Array;
                      validatorIndex?: number;
                  };
              };
              lightClientAttackEvidence?: {
                  byzantineValidators?: {
                      address?: Uint8Array;
                      proposerPriority?: bigint;
                      pubKey?: {
                          ed25519?: (...) | (...);
                          secp256k1?: (...) | (...);
                      };
                      votingPower?: bigint;
                  }[];
                  commonHeight?: bigint;
                  conflictingBlock?: {
                      signedHeader?: {
                          commit?: {
                              blockId?: ...;
                              height?: ...;
                              round?: ...;
                              signatures?: ...;
                          };
                          header?: {
                              appHash?: ...;
                              chainId?: ...;
                              consensusHash?: ...;
                              dataHash?: ...;
                              evidenceHash?: ...;
                              height?: ...;
                              lastBlockId?: ...;
                              lastCommitHash?: ...;
                              lastResultsHash?: ...;
                              nextValidatorsHash?: ...;
                              proposerAddress?: ...;
                              time?: ...;
                              validatorsHash?: ...;
                              version?: ...;
                          };
                      };
                      validatorSet?: {
                          proposer?: {
                              address?: ...;
                              proposerPriority?: ...;
                              pubKey?: ...;
                              votingPower?: ...;
                          };
                          totalVotingPower?: bigint;
                          validators?: (...)[];
                      };
                  };
                  timestamp?: Date;
                  totalVotingPower?: bigint;
              };
          }
          • OptionalduplicateVoteEvidence?: {
                timestamp?: Date;
                totalVotingPower?: bigint;
                validatorPower?: bigint;
                voteA?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
                voteB?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    type?: SignedMsgType;
                    validatorAddress?: Uint8Array;
                    validatorIndex?: number;
                };
            }
            • Optionaltimestamp?: Date
            • OptionaltotalVotingPower?: bigint
            • OptionalvalidatorPower?: bigint
            • OptionalvoteA?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: ...;
                          total?: ...;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  type?: SignedMsgType;
                  validatorAddress?: Uint8Array;
                  validatorIndex?: number;
              }
              • OptionalblockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: ...;
                        total?: ...;
                    };
                }

                zero if vote is nil.

                • Optionalhash?: Uint8Array
                • OptionalpartSetHeader?: {
                      hash?: ...;
                      total?: ...;
                  }
                  • Optionalhash?: ...
                  • Optionaltotal?: ...
              • Optionalheight?: bigint
              • Optionalround?: number
              • Optionalsignature?: Uint8Array
              • Optionaltimestamp?: Date
              • Optionaltype?: SignedMsgType
              • OptionalvalidatorAddress?: Uint8Array
              • OptionalvalidatorIndex?: number
            • OptionalvoteB?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: ...;
                          total?: ...;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  type?: SignedMsgType;
                  validatorAddress?: Uint8Array;
                  validatorIndex?: number;
              }
              • OptionalblockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: ...;
                        total?: ...;
                    };
                }

                zero if vote is nil.

                • Optionalhash?: Uint8Array
                • OptionalpartSetHeader?: {
                      hash?: ...;
                      total?: ...;
                  }
                  • Optionalhash?: ...
                  • Optionaltotal?: ...
              • Optionalheight?: bigint
              • Optionalround?: number
              • Optionalsignature?: Uint8Array
              • Optionaltimestamp?: Date
              • Optionaltype?: SignedMsgType
              • OptionalvalidatorAddress?: Uint8Array
              • OptionalvalidatorIndex?: number
          • OptionallightClientAttackEvidence?: {
                byzantineValidators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
                commonHeight?: bigint;
                conflictingBlock?: {
                    signedHeader?: {
                        commit?: {
                            blockId?: ...;
                            height?: ...;
                            round?: ...;
                            signatures?: ...;
                        };
                        header?: {
                            appHash?: ...;
                            chainId?: ...;
                            consensusHash?: ...;
                            dataHash?: ...;
                            evidenceHash?: ...;
                            height?: ...;
                            lastBlockId?: ...;
                            lastCommitHash?: ...;
                            lastResultsHash?: ...;
                            nextValidatorsHash?: ...;
                            proposerAddress?: ...;
                            time?: ...;
                            validatorsHash?: ...;
                            version?: ...;
                        };
                    };
                    validatorSet?: {
                        proposer?: {
                            address?: ...;
                            proposerPriority?: ...;
                            pubKey?: ...;
                            votingPower?: ...;
                        };
                        totalVotingPower?: bigint;
                        validators?: (...)[];
                    };
                };
                timestamp?: Date;
                totalVotingPower?: bigint;
            }
            • OptionalbyzantineValidators?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: (...) | (...);
                      secp256k1?: (...) | (...);
                  };
                  votingPower?: bigint;
              }[]
            • OptionalcommonHeight?: bigint
            • OptionalconflictingBlock?: {
                  signedHeader?: {
                      commit?: {
                          blockId?: ...;
                          height?: ...;
                          round?: ...;
                          signatures?: ...;
                      };
                      header?: {
                          appHash?: ...;
                          chainId?: ...;
                          consensusHash?: ...;
                          dataHash?: ...;
                          evidenceHash?: ...;
                          height?: ...;
                          lastBlockId?: ...;
                          lastCommitHash?: ...;
                          lastResultsHash?: ...;
                          nextValidatorsHash?: ...;
                          proposerAddress?: ...;
                          time?: ...;
                          validatorsHash?: ...;
                          version?: ...;
                      };
                  };
                  validatorSet?: {
                      proposer?: {
                          address?: ...;
                          proposerPriority?: ...;
                          pubKey?: ...;
                          votingPower?: ...;
                      };
                      totalVotingPower?: bigint;
                      validators?: (...)[];
                  };
              }
              • OptionalsignedHeader?: {
                    commit?: {
                        blockId?: ...;
                        height?: ...;
                        round?: ...;
                        signatures?: ...;
                    };
                    header?: {
                        appHash?: ...;
                        chainId?: ...;
                        consensusHash?: ...;
                        dataHash?: ...;
                        evidenceHash?: ...;
                        height?: ...;
                        lastBlockId?: ...;
                        lastCommitHash?: ...;
                        lastResultsHash?: ...;
                        nextValidatorsHash?: ...;
                        proposerAddress?: ...;
                        time?: ...;
                        validatorsHash?: ...;
                        version?: ...;
                    };
                }
                • Optionalcommit?: {
                      blockId?: ...;
                      height?: ...;
                      round?: ...;
                      signatures?: ...;
                  }
                  • OptionalblockId?: ...
                  • Optionalheight?: ...
                  • Optionalround?: ...
                  • Optionalsignatures?: ...
                • Optionalheader?: {
                      appHash?: ...;
                      chainId?: ...;
                      consensusHash?: ...;
                      dataHash?: ...;
                      evidenceHash?: ...;
                      height?: ...;
                      lastBlockId?: ...;
                      lastCommitHash?: ...;
                      lastResultsHash?: ...;
                      nextValidatorsHash?: ...;
                      proposerAddress?: ...;
                      time?: ...;
                      validatorsHash?: ...;
                      version?: ...;
                  }
                  • OptionalappHash?: ...

                    state after txs from the previous block

                  • OptionalchainId?: ...
                  • OptionalconsensusHash?: ...

                    consensus params for current block

                  • OptionaldataHash?: ...
                  • OptionalevidenceHash?: ...

                    consensus info

                  • Optionalheight?: ...
                  • OptionallastBlockId?: ...

                    prev block info

                  • OptionallastCommitHash?: ...

                    hashes of block data

                  • OptionallastResultsHash?: ...
                  • OptionalnextValidatorsHash?: ...

                    validators for the next block

                  • OptionalproposerAddress?: ...

                    original proposer of the block

                  • Optionaltime?: ...
                  • OptionalvalidatorsHash?: ...

                    hashes from the app output from the prev block

                  • Optionalversion?: ...

                    basic block info

              • OptionalvalidatorSet?: {
                    proposer?: {
                        address?: ...;
                        proposerPriority?: ...;
                        pubKey?: ...;
                        votingPower?: ...;
                    };
                    totalVotingPower?: bigint;
                    validators?: (...)[];
                }
                • Optionalproposer?: {
                      address?: ...;
                      proposerPriority?: ...;
                      pubKey?: ...;
                      votingPower?: ...;
                  }
                  • Optionaladdress?: ...
                  • OptionalproposerPriority?: ...
                  • OptionalpubKey?: ...
                  • OptionalvotingPower?: ...
                • OptionaltotalVotingPower?: bigint
                • Optionalvalidators?: (...)[]
            • Optionaltimestamp?: Date
            • OptionaltotalVotingPower?: bigint

        Returns Evidence

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • EvidenceList: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): EvidenceList;
        encode(message: EvidenceList, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceListAmino): EvidenceList;
        fromAminoMsg(object: EvidenceListAminoMsg): EvidenceList;
        fromPartial(object: {
            evidence?: {
                duplicateVoteEvidence?: {
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                    validatorPower?: bigint;
                    voteA?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                    voteB?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                };
                lightClientAttackEvidence?: {
                    byzantineValidators?: {
                        address?: ...;
                        proposerPriority?: ...;
                        pubKey?: ...;
                        votingPower?: ...;
                    }[];
                    commonHeight?: bigint;
                    conflictingBlock?: {
                        signedHeader?: (...) | (...);
                        validatorSet?: (...) | (...);
                    };
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                };
            }[];
        }): EvidenceList;
        fromProtoMsg(message: EvidenceListProtoMsg): EvidenceList;
        toAmino(message: EvidenceList): EvidenceListAmino;
        toProto(message: EvidenceList): Uint8Array;
        toProtoMsg(message: EvidenceList): EvidenceListProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns EvidenceList

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              evidence?: {
                  duplicateVoteEvidence?: {
                      timestamp?: Date;
                      totalVotingPower?: bigint;
                      validatorPower?: bigint;
                      voteA?: {
                          blockId?: (...) | (...);
                          height?: (...) | (...);
                          round?: (...) | (...);
                          signature?: (...) | (...);
                          timestamp?: (...) | (...);
                          type?: (...) | (...);
                          validatorAddress?: (...) | (...);
                          validatorIndex?: (...) | (...);
                      };
                      voteB?: {
                          blockId?: (...) | (...);
                          height?: (...) | (...);
                          round?: (...) | (...);
                          signature?: (...) | (...);
                          timestamp?: (...) | (...);
                          type?: (...) | (...);
                          validatorAddress?: (...) | (...);
                          validatorIndex?: (...) | (...);
                      };
                  };
                  lightClientAttackEvidence?: {
                      byzantineValidators?: {
                          address?: ...;
                          proposerPriority?: ...;
                          pubKey?: ...;
                          votingPower?: ...;
                      }[];
                      commonHeight?: bigint;
                      conflictingBlock?: {
                          signedHeader?: (...) | (...);
                          validatorSet?: (...) | (...);
                      };
                      timestamp?: Date;
                      totalVotingPower?: bigint;
                  };
              }[];
          }
          • Optionalevidence?: {
                duplicateVoteEvidence?: {
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                    validatorPower?: bigint;
                    voteA?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                    voteB?: {
                        blockId?: (...) | (...);
                        height?: (...) | (...);
                        round?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        type?: (...) | (...);
                        validatorAddress?: (...) | (...);
                        validatorIndex?: (...) | (...);
                    };
                };
                lightClientAttackEvidence?: {
                    byzantineValidators?: {
                        address?: ...;
                        proposerPriority?: ...;
                        pubKey?: ...;
                        votingPower?: ...;
                    }[];
                    commonHeight?: bigint;
                    conflictingBlock?: {
                        signedHeader?: (...) | (...);
                        validatorSet?: (...) | (...);
                    };
                    timestamp?: Date;
                    totalVotingPower?: bigint;
                };
            }[]

        Returns EvidenceList

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • EvidenceParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): EvidenceParams;
        encode(message: EvidenceParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceParamsAmino): EvidenceParams;
        fromAminoMsg(object: EvidenceParamsAminoMsg): EvidenceParams;
        fromPartial(object: {
            maxAgeDuration?: {
                nanos?: number;
                seconds?: bigint;
            };
            maxAgeNumBlocks?: bigint;
            maxBytes?: bigint;
        }): EvidenceParams;
        fromProtoMsg(message: EvidenceParamsProtoMsg): EvidenceParams;
        toAmino(message: EvidenceParams): EvidenceParamsAmino;
        toProto(message: EvidenceParams): Uint8Array;
        toProtoMsg(message: EvidenceParams): EvidenceParamsProtoMsg;
    }
    • typeUrl: string
    • decode:function
    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              maxAgeDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              };
              maxAgeNumBlocks?: bigint;
              maxBytes?: bigint;
          }
          • OptionalmaxAgeDuration?: {
                nanos?: number;
                seconds?: bigint;
            }

            Max age of evidence, in time.

            It should correspond with an app's "unbonding period" or other similar mechanism for handling Nothing-At-Stake attacks.

            • Optionalnanos?: number

              Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

            • Optionalseconds?: bigint

              Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

          • OptionalmaxAgeNumBlocks?: bigint

            Max age of evidence, in blocks.

            The basic formula for calculating this is: MaxAgeDuration / {average block time}.

          • OptionalmaxBytes?: bigint

            This sets the maximum size of total evidence in bytes that can be committed in a single block. and should fall comfortably under the max block bytes. Default is 1048576 or 1MB

        Returns EvidenceParams

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • HashedParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): HashedParams;
        encode(message: HashedParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HashedParamsAmino): HashedParams;
        fromAminoMsg(object: HashedParamsAminoMsg): HashedParams;
        fromPartial(object: {
            blockMaxBytes?: bigint;
            blockMaxGas?: bigint;
        }): HashedParams;
        fromProtoMsg(message: HashedParamsProtoMsg): HashedParams;
        toAmino(message: HashedParams): HashedParamsAmino;
        toProto(message: HashedParams): Uint8Array;
        toProtoMsg(message: HashedParams): HashedParamsProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns HashedParams

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              blockMaxBytes?: bigint;
              blockMaxGas?: bigint;
          }
          • OptionalblockMaxBytes?: bigint
          • OptionalblockMaxGas?: bigint

        Returns HashedParams

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Header: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Header;
        encode(message: Header, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HeaderAmino): Header;
        fromAminoMsg(object: HeaderAminoMsg): Header;
        fromPartial(object: {
            appHash?: Uint8Array;
            chainId?: string;
            consensusHash?: Uint8Array;
            dataHash?: Uint8Array;
            evidenceHash?: Uint8Array;
            height?: bigint;
            lastBlockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            lastCommitHash?: Uint8Array;
            lastResultsHash?: Uint8Array;
            nextValidatorsHash?: Uint8Array;
            proposerAddress?: Uint8Array;
            time?: Date;
            validatorsHash?: Uint8Array;
            version?: {
                app?: bigint;
                block?: bigint;
            };
        }): Header;
        fromProtoMsg(message: HeaderProtoMsg): Header;
        toAmino(message: Header): HeaderAmino;
        toProto(message: Header): Uint8Array;
        toProtoMsg(message: Header): HeaderProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Header

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Header

    • fromAminoMsg:function
      • Parameters

        Returns Header

    • fromPartial:function
      • Parameters

        • object: {
              appHash?: Uint8Array;
              chainId?: string;
              consensusHash?: Uint8Array;
              dataHash?: Uint8Array;
              evidenceHash?: Uint8Array;
              height?: bigint;
              lastBlockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              };
              lastCommitHash?: Uint8Array;
              lastResultsHash?: Uint8Array;
              nextValidatorsHash?: Uint8Array;
              proposerAddress?: Uint8Array;
              time?: Date;
              validatorsHash?: Uint8Array;
              version?: {
                  app?: bigint;
                  block?: bigint;
              };
          }
          • OptionalappHash?: Uint8Array

            state after txs from the previous block

          • OptionalchainId?: string
          • OptionalconsensusHash?: Uint8Array

            consensus params for current block

          • OptionaldataHash?: Uint8Array
          • OptionalevidenceHash?: Uint8Array

            consensus info

          • Optionalheight?: bigint
          • OptionallastBlockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            }

            prev block info

            • Optionalhash?: Uint8Array
            • OptionalpartSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              }
              • Optionalhash?: Uint8Array
              • Optionaltotal?: number
          • OptionallastCommitHash?: Uint8Array

            hashes of block data

          • OptionallastResultsHash?: Uint8Array
          • OptionalnextValidatorsHash?: Uint8Array

            validators for the next block

          • OptionalproposerAddress?: Uint8Array

            original proposer of the block

          • Optionaltime?: Date
          • OptionalvalidatorsHash?: Uint8Array

            hashes from the app output from the prev block

          • Optionalversion?: {
                app?: bigint;
                block?: bigint;
            }

            basic block info

            • Optionalapp?: bigint
            • Optionalblock?: bigint

        Returns Header

    • fromProtoMsg:function
      • Parameters

        Returns Header

    • toAmino:function
      • Parameters

        Returns HeaderAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • LightBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LightBlock;
        encode(message: LightBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LightBlockAmino): LightBlock;
        fromAminoMsg(object: LightBlockAminoMsg): LightBlock;
        fromPartial(object: {
            signedHeader?: {
                commit?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signatures?: {
                        blockIdFlag?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        validatorAddress?: (...) | (...);
                    }[];
                };
                header?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: bigint;
                        block?: bigint;
                    };
                };
            };
            validatorSet?: {
                proposer?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    };
                    votingPower?: bigint;
                };
                totalVotingPower?: bigint;
                validators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
            };
        }): LightBlock;
        fromProtoMsg(message: LightBlockProtoMsg): LightBlock;
        toAmino(message: LightBlock): LightBlockAmino;
        toProto(message: LightBlock): Uint8Array;
        toProtoMsg(message: LightBlock): LightBlockProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns LightBlock

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              signedHeader?: {
                  commit?: {
                      blockId?: {
                          hash?: Uint8Array;
                          partSetHeader?: {
                              hash?: ...;
                              total?: ...;
                          };
                      };
                      height?: bigint;
                      round?: number;
                      signatures?: {
                          blockIdFlag?: (...) | (...);
                          signature?: (...) | (...);
                          timestamp?: (...) | (...);
                          validatorAddress?: (...) | (...);
                      }[];
                  };
                  header?: {
                      appHash?: Uint8Array;
                      chainId?: string;
                      consensusHash?: Uint8Array;
                      dataHash?: Uint8Array;
                      evidenceHash?: Uint8Array;
                      height?: bigint;
                      lastBlockId?: {
                          hash?: Uint8Array;
                          partSetHeader?: {
                              hash?: ...;
                              total?: ...;
                          };
                      };
                      lastCommitHash?: Uint8Array;
                      lastResultsHash?: Uint8Array;
                      nextValidatorsHash?: Uint8Array;
                      proposerAddress?: Uint8Array;
                      time?: Date;
                      validatorsHash?: Uint8Array;
                      version?: {
                          app?: bigint;
                          block?: bigint;
                      };
                  };
              };
              validatorSet?: {
                  proposer?: {
                      address?: Uint8Array;
                      proposerPriority?: bigint;
                      pubKey?: {
                          ed25519?: Uint8Array;
                          secp256k1?: Uint8Array;
                      };
                      votingPower?: bigint;
                  };
                  totalVotingPower?: bigint;
                  validators?: {
                      address?: Uint8Array;
                      proposerPriority?: bigint;
                      pubKey?: {
                          ed25519?: (...) | (...);
                          secp256k1?: (...) | (...);
                      };
                      votingPower?: bigint;
                  }[];
              };
          }
          • OptionalsignedHeader?: {
                commit?: {
                    blockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    height?: bigint;
                    round?: number;
                    signatures?: {
                        blockIdFlag?: (...) | (...);
                        signature?: (...) | (...);
                        timestamp?: (...) | (...);
                        validatorAddress?: (...) | (...);
                    }[];
                };
                header?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: bigint;
                        block?: bigint;
                    };
                };
            }
            • Optionalcommit?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: ...;
                          total?: ...;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signatures?: {
                      blockIdFlag?: (...) | (...);
                      signature?: (...) | (...);
                      timestamp?: (...) | (...);
                      validatorAddress?: (...) | (...);
                  }[];
              }
              • OptionalblockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: ...;
                        total?: ...;
                    };
                }
                • Optionalhash?: Uint8Array
                • OptionalpartSetHeader?: {
                      hash?: ...;
                      total?: ...;
                  }
                  • Optionalhash?: ...
                  • Optionaltotal?: ...
              • Optionalheight?: bigint
              • Optionalround?: number
              • Optionalsignatures?: {
                    blockIdFlag?: (...) | (...);
                    signature?: (...) | (...);
                    timestamp?: (...) | (...);
                    validatorAddress?: (...) | (...);
                }[]
            • Optionalheader?: {
                  appHash?: Uint8Array;
                  chainId?: string;
                  consensusHash?: Uint8Array;
                  dataHash?: Uint8Array;
                  evidenceHash?: Uint8Array;
                  height?: bigint;
                  lastBlockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: ...;
                          total?: ...;
                      };
                  };
                  lastCommitHash?: Uint8Array;
                  lastResultsHash?: Uint8Array;
                  nextValidatorsHash?: Uint8Array;
                  proposerAddress?: Uint8Array;
                  time?: Date;
                  validatorsHash?: Uint8Array;
                  version?: {
                      app?: bigint;
                      block?: bigint;
                  };
              }
              • OptionalappHash?: Uint8Array

                state after txs from the previous block

              • OptionalchainId?: string
              • OptionalconsensusHash?: Uint8Array

                consensus params for current block

              • OptionaldataHash?: Uint8Array
              • OptionalevidenceHash?: Uint8Array

                consensus info

              • Optionalheight?: bigint
              • OptionallastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: ...;
                        total?: ...;
                    };
                }

                prev block info

                • Optionalhash?: Uint8Array
                • OptionalpartSetHeader?: {
                      hash?: ...;
                      total?: ...;
                  }
                  • Optionalhash?: ...
                  • Optionaltotal?: ...
              • OptionallastCommitHash?: Uint8Array

                hashes of block data

              • OptionallastResultsHash?: Uint8Array
              • OptionalnextValidatorsHash?: Uint8Array

                validators for the next block

              • OptionalproposerAddress?: Uint8Array

                original proposer of the block

              • Optionaltime?: Date
              • OptionalvalidatorsHash?: Uint8Array

                hashes from the app output from the prev block

              • Optionalversion?: {
                    app?: bigint;
                    block?: bigint;
                }

                basic block info

                • Optionalapp?: bigint
                • Optionalblock?: bigint
          • OptionalvalidatorSet?: {
                proposer?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    };
                    votingPower?: bigint;
                };
                totalVotingPower?: bigint;
                validators?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                    votingPower?: bigint;
                }[];
            }
            • Optionalproposer?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: Uint8Array;
                      secp256k1?: Uint8Array;
                  };
                  votingPower?: bigint;
              }
              • Optionaladdress?: Uint8Array
              • OptionalproposerPriority?: bigint
              • OptionalpubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                }
                • Optionaled25519?: Uint8Array
                • Optionalsecp256k1?: Uint8Array
              • OptionalvotingPower?: bigint
            • OptionaltotalVotingPower?: bigint
            • Optionalvalidators?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: (...) | (...);
                      secp256k1?: (...) | (...);
                  };
                  votingPower?: bigint;
              }[]

        Returns LightBlock

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • LightClientAttackEvidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LightClientAttackEvidence;
        encode(message: LightClientAttackEvidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LightClientAttackEvidenceAmino): LightClientAttackEvidence;
        fromAminoMsg(object: LightClientAttackEvidenceAminoMsg): LightClientAttackEvidence;
        fromPartial(object: {
            byzantineValidators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[];
            commonHeight?: bigint;
            conflictingBlock?: {
                signedHeader?: {
                    commit?: {
                        blockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        height?: bigint;
                        round?: number;
                        signatures?: (...)[];
                    };
                    header?: {
                        appHash?: Uint8Array;
                        chainId?: string;
                        consensusHash?: Uint8Array;
                        dataHash?: Uint8Array;
                        evidenceHash?: Uint8Array;
                        height?: bigint;
                        lastBlockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        lastCommitHash?: Uint8Array;
                        lastResultsHash?: Uint8Array;
                        nextValidatorsHash?: Uint8Array;
                        proposerAddress?: Uint8Array;
                        time?: Date;
                        validatorsHash?: Uint8Array;
                        version?: {
                            app?: ...;
                            block?: ...;
                        };
                    };
                };
                validatorSet?: {
                    proposer?: {
                        address?: Uint8Array;
                        proposerPriority?: bigint;
                        pubKey?: {
                            ed25519?: ...;
                            secp256k1?: ...;
                        };
                        votingPower?: bigint;
                    };
                    totalVotingPower?: bigint;
                    validators?: {
                        address?: (...) | (...);
                        proposerPriority?: (...) | (...);
                        pubKey?: (...) | (...);
                        votingPower?: (...) | (...);
                    }[];
                };
            };
            timestamp?: Date;
            totalVotingPower?: bigint;
        }): LightClientAttackEvidence;
        fromProtoMsg(message: LightClientAttackEvidenceProtoMsg): LightClientAttackEvidence;
        toAmino(message: LightClientAttackEvidence): LightClientAttackEvidenceAmino;
        toProto(message: LightClientAttackEvidence): Uint8Array;
        toProtoMsg(message: LightClientAttackEvidence): LightClientAttackEvidenceProtoMsg;
    }
    • typeUrl: string
    • decode:function
    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              byzantineValidators?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: Uint8Array;
                      secp256k1?: Uint8Array;
                  };
                  votingPower?: bigint;
              }[];
              commonHeight?: bigint;
              conflictingBlock?: {
                  signedHeader?: {
                      commit?: {
                          blockId?: {
                              hash?: ...;
                              partSetHeader?: ...;
                          };
                          height?: bigint;
                          round?: number;
                          signatures?: (...)[];
                      };
                      header?: {
                          appHash?: Uint8Array;
                          chainId?: string;
                          consensusHash?: Uint8Array;
                          dataHash?: Uint8Array;
                          evidenceHash?: Uint8Array;
                          height?: bigint;
                          lastBlockId?: {
                              hash?: ...;
                              partSetHeader?: ...;
                          };
                          lastCommitHash?: Uint8Array;
                          lastResultsHash?: Uint8Array;
                          nextValidatorsHash?: Uint8Array;
                          proposerAddress?: Uint8Array;
                          time?: Date;
                          validatorsHash?: Uint8Array;
                          version?: {
                              app?: ...;
                              block?: ...;
                          };
                      };
                  };
                  validatorSet?: {
                      proposer?: {
                          address?: Uint8Array;
                          proposerPriority?: bigint;
                          pubKey?: {
                              ed25519?: ...;
                              secp256k1?: ...;
                          };
                          votingPower?: bigint;
                      };
                      totalVotingPower?: bigint;
                      validators?: {
                          address?: (...) | (...);
                          proposerPriority?: (...) | (...);
                          pubKey?: (...) | (...);
                          votingPower?: (...) | (...);
                      }[];
                  };
              };
              timestamp?: Date;
              totalVotingPower?: bigint;
          }
          • OptionalbyzantineValidators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[]
          • OptionalcommonHeight?: bigint
          • OptionalconflictingBlock?: {
                signedHeader?: {
                    commit?: {
                        blockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        height?: bigint;
                        round?: number;
                        signatures?: (...)[];
                    };
                    header?: {
                        appHash?: Uint8Array;
                        chainId?: string;
                        consensusHash?: Uint8Array;
                        dataHash?: Uint8Array;
                        evidenceHash?: Uint8Array;
                        height?: bigint;
                        lastBlockId?: {
                            hash?: ...;
                            partSetHeader?: ...;
                        };
                        lastCommitHash?: Uint8Array;
                        lastResultsHash?: Uint8Array;
                        nextValidatorsHash?: Uint8Array;
                        proposerAddress?: Uint8Array;
                        time?: Date;
                        validatorsHash?: Uint8Array;
                        version?: {
                            app?: ...;
                            block?: ...;
                        };
                    };
                };
                validatorSet?: {
                    proposer?: {
                        address?: Uint8Array;
                        proposerPriority?: bigint;
                        pubKey?: {
                            ed25519?: ...;
                            secp256k1?: ...;
                        };
                        votingPower?: bigint;
                    };
                    totalVotingPower?: bigint;
                    validators?: {
                        address?: (...) | (...);
                        proposerPriority?: (...) | (...);
                        pubKey?: (...) | (...);
                        votingPower?: (...) | (...);
                    }[];
                };
            }
            • OptionalsignedHeader?: {
                  commit?: {
                      blockId?: {
                          hash?: ...;
                          partSetHeader?: ...;
                      };
                      height?: bigint;
                      round?: number;
                      signatures?: (...)[];
                  };
                  header?: {
                      appHash?: Uint8Array;
                      chainId?: string;
                      consensusHash?: Uint8Array;
                      dataHash?: Uint8Array;
                      evidenceHash?: Uint8Array;
                      height?: bigint;
                      lastBlockId?: {
                          hash?: ...;
                          partSetHeader?: ...;
                      };
                      lastCommitHash?: Uint8Array;
                      lastResultsHash?: Uint8Array;
                      nextValidatorsHash?: Uint8Array;
                      proposerAddress?: Uint8Array;
                      time?: Date;
                      validatorsHash?: Uint8Array;
                      version?: {
                          app?: ...;
                          block?: ...;
                      };
                  };
              }
              • Optionalcommit?: {
                    blockId?: {
                        hash?: ...;
                        partSetHeader?: ...;
                    };
                    height?: bigint;
                    round?: number;
                    signatures?: (...)[];
                }
                • OptionalblockId?: {
                      hash?: ...;
                      partSetHeader?: ...;
                  }
                  • Optionalhash?: ...
                  • OptionalpartSetHeader?: ...
                • Optionalheight?: bigint
                • Optionalround?: number
                • Optionalsignatures?: (...)[]
              • Optionalheader?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: ...;
                        partSetHeader?: ...;
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: ...;
                        block?: ...;
                    };
                }
                • OptionalappHash?: Uint8Array

                  state after txs from the previous block

                • OptionalchainId?: string
                • OptionalconsensusHash?: Uint8Array

                  consensus params for current block

                • OptionaldataHash?: Uint8Array
                • OptionalevidenceHash?: Uint8Array

                  consensus info

                • Optionalheight?: bigint
                • OptionallastBlockId?: {
                      hash?: ...;
                      partSetHeader?: ...;
                  }

                  prev block info

                  • Optionalhash?: ...
                  • OptionalpartSetHeader?: ...
                • OptionallastCommitHash?: Uint8Array

                  hashes of block data

                • OptionallastResultsHash?: Uint8Array
                • OptionalnextValidatorsHash?: Uint8Array

                  validators for the next block

                • OptionalproposerAddress?: Uint8Array

                  original proposer of the block

                • Optionaltime?: Date
                • OptionalvalidatorsHash?: Uint8Array

                  hashes from the app output from the prev block

                • Optionalversion?: {
                      app?: ...;
                      block?: ...;
                  }

                  basic block info

                  • Optionalapp?: ...
                  • Optionalblock?: ...
            • OptionalvalidatorSet?: {
                  proposer?: {
                      address?: Uint8Array;
                      proposerPriority?: bigint;
                      pubKey?: {
                          ed25519?: ...;
                          secp256k1?: ...;
                      };
                      votingPower?: bigint;
                  };
                  totalVotingPower?: bigint;
                  validators?: {
                      address?: (...) | (...);
                      proposerPriority?: (...) | (...);
                      pubKey?: (...) | (...);
                      votingPower?: (...) | (...);
                  }[];
              }
              • Optionalproposer?: {
                    address?: Uint8Array;
                    proposerPriority?: bigint;
                    pubKey?: {
                        ed25519?: ...;
                        secp256k1?: ...;
                    };
                    votingPower?: bigint;
                }
                • Optionaladdress?: Uint8Array
                • OptionalproposerPriority?: bigint
                • OptionalpubKey?: {
                      ed25519?: ...;
                      secp256k1?: ...;
                  }
                  • Optionaled25519?: ...
                  • Optionalsecp256k1?: ...
                • OptionalvotingPower?: bigint
              • OptionaltotalVotingPower?: bigint
              • Optionalvalidators?: {
                    address?: (...) | (...);
                    proposerPriority?: (...) | (...);
                    pubKey?: (...) | (...);
                    votingPower?: (...) | (...);
                }[]
          • Optionaltimestamp?: Date
          • OptionaltotalVotingPower?: bigint

        Returns LightClientAttackEvidence

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Part: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Part;
        encode(message: Part, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PartAmino): Part;
        fromAminoMsg(object: PartAminoMsg): Part;
        fromPartial(object: {
            bytes?: Uint8Array;
            index?: number;
            proof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            };
        }): Part;
        fromProtoMsg(message: PartProtoMsg): Part;
        toAmino(message: Part): PartAmino;
        toProto(message: Part): Uint8Array;
        toProtoMsg(message: Part): PartProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Part

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Part

    • fromAminoMsg:function
      • Parameters

        Returns Part

    • fromPartial:function
      • Parameters

        • object: {
              bytes?: Uint8Array;
              index?: number;
              proof?: {
                  aunts?: Uint8Array[];
                  index?: bigint;
                  leafHash?: Uint8Array;
                  total?: bigint;
              };
          }
          • Optionalbytes?: Uint8Array
          • Optionalindex?: number
          • Optionalproof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            }
            • Optionalaunts?: Uint8Array[]
            • Optionalindex?: bigint
            • OptionalleafHash?: Uint8Array
            • Optionaltotal?: bigint

        Returns Part

    • fromProtoMsg:function
      • Parameters

        Returns Part

    • toAmino:function
      • Parameters

        Returns PartAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
      • Parameters

        Returns PartProtoMsg

  • PartSetHeader: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PartSetHeader;
        encode(message: PartSetHeader, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PartSetHeaderAmino): PartSetHeader;
        fromAminoMsg(object: PartSetHeaderAminoMsg): PartSetHeader;
        fromPartial(object: {
            hash?: Uint8Array;
            total?: number;
        }): PartSetHeader;
        fromProtoMsg(message: PartSetHeaderProtoMsg): PartSetHeader;
        toAmino(message: PartSetHeader): PartSetHeaderAmino;
        toProto(message: PartSetHeader): Uint8Array;
        toProtoMsg(message: PartSetHeader): PartSetHeaderProtoMsg;
    }
  • Proposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Proposal;
        encode(message: Proposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ProposalAmino): Proposal;
        fromAminoMsg(object: ProposalAminoMsg): Proposal;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            polRound?: number;
            round?: number;
            signature?: Uint8Array;
            timestamp?: Date;
            type?: SignedMsgType;
        }): Proposal;
        fromProtoMsg(message: ProposalProtoMsg): Proposal;
        toAmino(message: Proposal): ProposalAmino;
        toProto(message: Proposal): Uint8Array;
        toProtoMsg(message: Proposal): ProposalProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Proposal

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              blockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              };
              height?: bigint;
              polRound?: number;
              round?: number;
              signature?: Uint8Array;
              timestamp?: Date;
              type?: SignedMsgType;
          }
          • OptionalblockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            }
            • Optionalhash?: Uint8Array
            • OptionalpartSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              }
              • Optionalhash?: Uint8Array
              • Optionaltotal?: number
          • Optionalheight?: bigint
          • OptionalpolRound?: number
          • Optionalround?: number
          • Optionalsignature?: Uint8Array
          • Optionaltimestamp?: Date
          • Optionaltype?: SignedMsgType

        Returns Proposal

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • SignedHeader: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SignedHeader;
        encode(message: SignedHeader, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SignedHeaderAmino): SignedHeader;
        fromAminoMsg(object: SignedHeaderAminoMsg): SignedHeader;
        fromPartial(object: {
            commit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            };
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
        }): SignedHeader;
        fromProtoMsg(message: SignedHeaderProtoMsg): SignedHeader;
        toAmino(message: SignedHeader): SignedHeaderAmino;
        toProto(message: SignedHeader): Uint8Array;
        toProtoMsg(message: SignedHeader): SignedHeaderProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns SignedHeader

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              commit?: {
                  blockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  height?: bigint;
                  round?: number;
                  signatures?: {
                      blockIdFlag?: BlockIDFlag;
                      signature?: Uint8Array;
                      timestamp?: Date;
                      validatorAddress?: Uint8Array;
                  }[];
              };
              header?: {
                  appHash?: Uint8Array;
                  chainId?: string;
                  consensusHash?: Uint8Array;
                  dataHash?: Uint8Array;
                  evidenceHash?: Uint8Array;
                  height?: bigint;
                  lastBlockId?: {
                      hash?: Uint8Array;
                      partSetHeader?: {
                          hash?: Uint8Array;
                          total?: number;
                      };
                  };
                  lastCommitHash?: Uint8Array;
                  lastResultsHash?: Uint8Array;
                  nextValidatorsHash?: Uint8Array;
                  proposerAddress?: Uint8Array;
                  time?: Date;
                  validatorsHash?: Uint8Array;
                  version?: {
                      app?: bigint;
                      block?: bigint;
                  };
              };
          }
          • Optionalcommit?: {
                blockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                height?: bigint;
                round?: number;
                signatures?: {
                    blockIdFlag?: BlockIDFlag;
                    signature?: Uint8Array;
                    timestamp?: Date;
                    validatorAddress?: Uint8Array;
                }[];
            }
            • OptionalblockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }
              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • Optionalheight?: bigint
            • Optionalround?: number
            • Optionalsignatures?: {
                  blockIdFlag?: BlockIDFlag;
                  signature?: Uint8Array;
                  timestamp?: Date;
                  validatorAddress?: Uint8Array;
              }[]
          • Optionalheader?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            }
            • OptionalappHash?: Uint8Array

              state after txs from the previous block

            • OptionalchainId?: string
            • OptionalconsensusHash?: Uint8Array

              consensus params for current block

            • OptionaldataHash?: Uint8Array
            • OptionalevidenceHash?: Uint8Array

              consensus info

            • Optionalheight?: bigint
            • OptionallastBlockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              }

              prev block info

              • Optionalhash?: Uint8Array
              • OptionalpartSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                }
                • Optionalhash?: Uint8Array
                • Optionaltotal?: number
            • OptionallastCommitHash?: Uint8Array

              hashes of block data

            • OptionallastResultsHash?: Uint8Array
            • OptionalnextValidatorsHash?: Uint8Array

              validators for the next block

            • OptionalproposerAddress?: Uint8Array

              original proposer of the block

            • Optionaltime?: Date
            • OptionalvalidatorsHash?: Uint8Array

              hashes from the app output from the prev block

            • Optionalversion?: {
                  app?: bigint;
                  block?: bigint;
              }

              basic block info

              • Optionalapp?: bigint
              • Optionalblock?: bigint

        Returns SignedHeader

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • SignedMsgTypeAmino: typeof SignedMsgType
  • SignedMsgTypeSDKType: typeof SignedMsgType
  • SimpleValidator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SimpleValidator;
        encode(message: SimpleValidator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SimpleValidatorAmino): SimpleValidator;
        fromAminoMsg(object: SimpleValidatorAminoMsg): SimpleValidator;
        fromPartial(object: {
            pubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            };
            votingPower?: bigint;
        }): SimpleValidator;
        fromProtoMsg(message: SimpleValidatorProtoMsg): SimpleValidator;
        toAmino(message: SimpleValidator): SimpleValidatorAmino;
        toProto(message: SimpleValidator): Uint8Array;
        toProtoMsg(message: SimpleValidator): SimpleValidatorProtoMsg;
    }
  • TxProof: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TxProof;
        encode(message: TxProof, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TxProofAmino): TxProof;
        fromAminoMsg(object: TxProofAminoMsg): TxProof;
        fromPartial(object: {
            data?: Uint8Array;
            proof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            };
            rootHash?: Uint8Array;
        }): TxProof;
        fromProtoMsg(message: TxProofProtoMsg): TxProof;
        toAmino(message: TxProof): TxProofAmino;
        toProto(message: TxProof): Uint8Array;
        toProtoMsg(message: TxProof): TxProofProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns TxProof

    • encode:function
    • fromAmino:function
      • Parameters

        Returns TxProof

    • fromAminoMsg:function
      • Parameters

        Returns TxProof

    • fromPartial:function
      • Parameters

        • object: {
              data?: Uint8Array;
              proof?: {
                  aunts?: Uint8Array[];
                  index?: bigint;
                  leafHash?: Uint8Array;
                  total?: bigint;
              };
              rootHash?: Uint8Array;
          }
          • Optionaldata?: Uint8Array
          • Optionalproof?: {
                aunts?: Uint8Array[];
                index?: bigint;
                leafHash?: Uint8Array;
                total?: bigint;
            }
            • Optionalaunts?: Uint8Array[]
            • Optionalindex?: bigint
            • OptionalleafHash?: Uint8Array
            • Optionaltotal?: bigint
          • OptionalrootHash?: Uint8Array

        Returns TxProof

    • fromProtoMsg:function
      • Parameters

        Returns TxProof

    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • Validator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Validator;
        encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorAmino): Validator;
        fromAminoMsg(object: ValidatorAminoMsg): Validator;
        fromPartial(object: {
            address?: Uint8Array;
            proposerPriority?: bigint;
            pubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            };
            votingPower?: bigint;
        }): Validator;
        fromProtoMsg(message: ValidatorProtoMsg): Validator;
        toAmino(message: Validator): ValidatorAmino;
        toProto(message: Validator): Uint8Array;
        toProtoMsg(message: Validator): ValidatorProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Validator

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              address?: Uint8Array;
              proposerPriority?: bigint;
              pubKey?: {
                  ed25519?: Uint8Array;
                  secp256k1?: Uint8Array;
              };
              votingPower?: bigint;
          }
          • Optionaladdress?: Uint8Array
          • OptionalproposerPriority?: bigint
          • OptionalpubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            }
            • Optionaled25519?: Uint8Array
            • Optionalsecp256k1?: Uint8Array
          • OptionalvotingPower?: bigint

        Returns Validator

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • ValidatorParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValidatorParams;
        encode(message: ValidatorParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorParamsAmino): ValidatorParams;
        fromAminoMsg(object: ValidatorParamsAminoMsg): ValidatorParams;
        fromPartial(object: {
            pubKeyTypes?: string[];
        }): ValidatorParams;
        fromProtoMsg(message: ValidatorParamsProtoMsg): ValidatorParams;
        toAmino(message: ValidatorParams): ValidatorParamsAmino;
        toProto(message: ValidatorParams): Uint8Array;
        toProtoMsg(message: ValidatorParams): ValidatorParamsProtoMsg;
    }
  • ValidatorSet: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValidatorSet;
        encode(message: ValidatorSet, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorSetAmino): ValidatorSet;
        fromAminoMsg(object: ValidatorSetAminoMsg): ValidatorSet;
        fromPartial(object: {
            proposer?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            };
            totalVotingPower?: bigint;
            validators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[];
        }): ValidatorSet;
        fromProtoMsg(message: ValidatorSetProtoMsg): ValidatorSet;
        toAmino(message: ValidatorSet): ValidatorSetAmino;
        toProto(message: ValidatorSet): Uint8Array;
        toProtoMsg(message: ValidatorSet): ValidatorSetProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns ValidatorSet

    • encode:function
    • fromAmino:function
    • fromAminoMsg:function
    • fromPartial:function
      • Parameters

        • object: {
              proposer?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: Uint8Array;
                      secp256k1?: Uint8Array;
                  };
                  votingPower?: bigint;
              };
              totalVotingPower?: bigint;
              validators?: {
                  address?: Uint8Array;
                  proposerPriority?: bigint;
                  pubKey?: {
                      ed25519?: Uint8Array;
                      secp256k1?: Uint8Array;
                  };
                  votingPower?: bigint;
              }[];
          }
          • Optionalproposer?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }
            • Optionaladdress?: Uint8Array
            • OptionalproposerPriority?: bigint
            • OptionalpubKey?: {
                  ed25519?: Uint8Array;
                  secp256k1?: Uint8Array;
              }
              • Optionaled25519?: Uint8Array
              • Optionalsecp256k1?: Uint8Array
            • OptionalvotingPower?: bigint
          • OptionaltotalVotingPower?: bigint
          • Optionalvalidators?: {
                address?: Uint8Array;
                proposerPriority?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
                votingPower?: bigint;
            }[]

        Returns ValidatorSet

    • fromProtoMsg:function
    • toAmino:function
    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
  • VersionParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): VersionParams;
        encode(message: VersionParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VersionParamsAmino): VersionParams;
        fromAminoMsg(object: VersionParamsAminoMsg): VersionParams;
        fromPartial(object: {
            appVersion?: bigint;
        }): VersionParams;
        fromProtoMsg(message: VersionParamsProtoMsg): VersionParams;
        toAmino(message: VersionParams): VersionParamsAmino;
        toProto(message: VersionParams): Uint8Array;
        toProtoMsg(message: VersionParams): VersionParamsProtoMsg;
    }
  • Vote: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Vote;
        encode(message: Vote, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VoteAmino): Vote;
        fromAminoMsg(object: VoteAminoMsg): Vote;
        fromPartial(object: {
            blockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            };
            height?: bigint;
            round?: number;
            signature?: Uint8Array;
            timestamp?: Date;
            type?: SignedMsgType;
            validatorAddress?: Uint8Array;
            validatorIndex?: number;
        }): Vote;
        fromProtoMsg(message: VoteProtoMsg): Vote;
        toAmino(message: Vote): VoteAmino;
        toProto(message: Vote): Uint8Array;
        toProtoMsg(message: Vote): VoteProtoMsg;
    }
    • typeUrl: string
    • decode:function
      • Parameters

        Returns Vote

    • encode:function
    • fromAmino:function
      • Parameters

        Returns Vote

    • fromAminoMsg:function
      • Parameters

        Returns Vote

    • fromPartial:function
      • Parameters

        • object: {
              blockId?: {
                  hash?: Uint8Array;
                  partSetHeader?: {
                      hash?: Uint8Array;
                      total?: number;
                  };
              };
              height?: bigint;
              round?: number;
              signature?: Uint8Array;
              timestamp?: Date;
              type?: SignedMsgType;
              validatorAddress?: Uint8Array;
              validatorIndex?: number;
          }
          • OptionalblockId?: {
                hash?: Uint8Array;
                partSetHeader?: {
                    hash?: Uint8Array;
                    total?: number;
                };
            }

            zero if vote is nil.

            • Optionalhash?: Uint8Array
            • OptionalpartSetHeader?: {
                  hash?: Uint8Array;
                  total?: number;
              }
              • Optionalhash?: Uint8Array
              • Optionaltotal?: number
          • Optionalheight?: bigint
          • Optionalround?: number
          • Optionalsignature?: Uint8Array
          • Optionaltimestamp?: Date
          • Optionaltype?: SignedMsgType
          • OptionalvalidatorAddress?: Uint8Array
          • OptionalvalidatorIndex?: number

        Returns Vote

    • fromProtoMsg:function
      • Parameters

        Returns Vote

    • toAmino:function
      • Parameters

        Returns VoteAmino

    • toProto:function
      • Parameters

        Returns Uint8Array

    • toProtoMsg:function
      • Parameters

        Returns VoteProtoMsg

  • blockIDFlagFromJSON:function
    • Parameters

      • object: any

      Returns BlockIDFlag

  • blockIDFlagToJSON:function
    • Parameters

      Returns string

  • signedMsgTypeFromJSON:function
    • Parameters

      • object: any

      Returns SignedMsgType

  • signedMsgTypeToJSON:function
    • Parameters

      Returns string