@bandprotocol/bandchain.js
Version:
TypeScript library for Cosmos SDK and BandChain
944 lines (943 loc) • 44.9 kB
TypeScript
import { Result, ResultAmino, ResultSDKType } from "../../../oracle/v1/oracle";
import { BinaryReader, BinaryWriter } from "../../../../binary";
/** ProofRequest is request type for the Service/Proof RPC method. */
export interface ProofRequest {
/** RequestID is ID of an oracle request */
requestId: bigint;
/** height is block height */
height: bigint;
}
export interface ProofRequestProtoMsg {
typeUrl: "/band.base.oracle.v1.ProofRequest";
value: Uint8Array;
}
/** ProofRequest is request type for the Service/Proof RPC method. */
export interface ProofRequestAmino {
/** RequestID is ID of an oracle request */
request_id?: string;
/** height is block height */
height?: string;
}
export interface ProofRequestAminoMsg {
type: "/band.base.oracle.v1.ProofRequest";
value: ProofRequestAmino;
}
/** ProofRequest is request type for the Service/Proof RPC method. */
export interface ProofRequestSDKType {
request_id: bigint;
height: bigint;
}
/** ProofResponse is response type for the Service/Proof RPC method. */
export interface ProofResponse {
/** height is block height */
height: bigint;
/** result is the proof */
result: SingleProofResult;
}
export interface ProofResponseProtoMsg {
typeUrl: "/band.base.oracle.v1.ProofResponse";
value: Uint8Array;
}
/** ProofResponse is response type for the Service/Proof RPC method. */
export interface ProofResponseAmino {
/** height is block height */
height?: string;
/** result is the proof */
result?: SingleProofResultAmino;
}
export interface ProofResponseAminoMsg {
type: "/band.base.oracle.v1.ProofResponse";
value: ProofResponseAmino;
}
/** ProofResponse is response type for the Service/Proof RPC method. */
export interface ProofResponseSDKType {
height: bigint;
result: SingleProofResultSDKType;
}
/** MultiProofRequest is request type for the Service/MultiProof RPC method. */
export interface MultiProofRequest {
/** request_ids is the list of request IDs */
requestIds: bigint[];
}
export interface MultiProofRequestProtoMsg {
typeUrl: "/band.base.oracle.v1.MultiProofRequest";
value: Uint8Array;
}
/** MultiProofRequest is request type for the Service/MultiProof RPC method. */
export interface MultiProofRequestAmino {
/** request_ids is the list of request IDs */
request_ids?: string[];
}
export interface MultiProofRequestAminoMsg {
type: "/band.base.oracle.v1.MultiProofRequest";
value: MultiProofRequestAmino;
}
/** MultiProofRequest is request type for the Service/MultiProof RPC method. */
export interface MultiProofRequestSDKType {
request_ids: bigint[];
}
/** MultiProofResponse is response type for the Service/MultiProof RPC method. */
export interface MultiProofResponse {
height: bigint;
result: MultiProofResult;
}
export interface MultiProofResponseProtoMsg {
typeUrl: "/band.base.oracle.v1.MultiProofResponse";
value: Uint8Array;
}
/** MultiProofResponse is response type for the Service/MultiProof RPC method. */
export interface MultiProofResponseAmino {
height?: string;
result?: MultiProofResultAmino;
}
export interface MultiProofResponseAminoMsg {
type: "/band.base.oracle.v1.MultiProofResponse";
value: MultiProofResponseAmino;
}
/** MultiProofResponse is response type for the Service/MultiProof RPC method. */
export interface MultiProofResponseSDKType {
height: bigint;
result: MultiProofResultSDKType;
}
/** RequestCountProofRequest is request type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofRequest {
}
export interface RequestCountProofRequestProtoMsg {
typeUrl: "/band.base.oracle.v1.RequestCountProofRequest";
value: Uint8Array;
}
/** RequestCountProofRequest is request type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofRequestAmino {
}
export interface RequestCountProofRequestAminoMsg {
type: "/band.base.oracle.v1.RequestCountProofRequest";
value: RequestCountProofRequestAmino;
}
/** RequestCountProofRequest is request type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofRequestSDKType {
}
/** RequestCountProofResponse is response type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofResponse {
height: bigint;
result: CountProofResult;
}
export interface RequestCountProofResponseProtoMsg {
typeUrl: "/band.base.oracle.v1.RequestCountProofResponse";
value: Uint8Array;
}
/** RequestCountProofResponse is response type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofResponseAmino {
height?: string;
result?: CountProofResultAmino;
}
export interface RequestCountProofResponseAminoMsg {
type: "/band.base.oracle.v1.RequestCountProofResponse";
value: RequestCountProofResponseAmino;
}
/** RequestCountProofResponse is response type for the Service/RequestCountProof RPC method. */
export interface RequestCountProofResponseSDKType {
height: bigint;
result: CountProofResultSDKType;
}
/** SingleProofResponse is the data structure for response of single proof */
export interface SingleProofResult {
proof: SingleProof;
evmProofBytes: Uint8Array;
}
export interface SingleProofResultProtoMsg {
typeUrl: "/band.base.oracle.v1.SingleProofResult";
value: Uint8Array;
}
/** SingleProofResponse is the data structure for response of single proof */
export interface SingleProofResultAmino {
proof?: SingleProofAmino;
evm_proof_bytes?: string;
}
export interface SingleProofResultAminoMsg {
type: "/band.base.oracle.v1.SingleProofResult";
value: SingleProofResultAmino;
}
/** SingleProofResponse is the data structure for response of single proof */
export interface SingleProofResultSDKType {
proof: SingleProofSDKType;
evm_proof_bytes: Uint8Array;
}
/** MultiProofResult is the data structure for response of multi proof */
export interface MultiProofResult {
proof: MultiProof;
evmProofBytes: Uint8Array;
}
export interface MultiProofResultProtoMsg {
typeUrl: "/band.base.oracle.v1.MultiProofResult";
value: Uint8Array;
}
/** MultiProofResult is the data structure for response of multi proof */
export interface MultiProofResultAmino {
proof?: MultiProofAmino;
evm_proof_bytes?: string;
}
export interface MultiProofResultAminoMsg {
type: "/band.base.oracle.v1.MultiProofResult";
value: MultiProofResultAmino;
}
/** MultiProofResult is the data structure for response of multi proof */
export interface MultiProofResultSDKType {
proof: MultiProofSDKType;
evm_proof_bytes: Uint8Array;
}
/** CountProofResult is the data structure for response of count proof */
export interface CountProofResult {
proof: CountProof;
evmProofBytes: Uint8Array;
}
export interface CountProofResultProtoMsg {
typeUrl: "/band.base.oracle.v1.CountProofResult";
value: Uint8Array;
}
/** CountProofResult is the data structure for response of count proof */
export interface CountProofResultAmino {
proof?: CountProofAmino;
evm_proof_bytes?: string;
}
export interface CountProofResultAminoMsg {
type: "/band.base.oracle.v1.CountProofResult";
value: CountProofResultAmino;
}
/** CountProofResult is the data structure for response of count proof */
export interface CountProofResultSDKType {
proof: CountProofSDKType;
evm_proof_bytes: Uint8Array;
}
/** SingleProof contains block height, oracle data proof and block relay proof */
export interface SingleProof {
blockHeight: bigint;
oracleDataProof: OracleDataProof;
blockRelayProof: BlockRelayProof;
}
export interface SingleProofProtoMsg {
typeUrl: "/band.base.oracle.v1.SingleProof";
value: Uint8Array;
}
/** SingleProof contains block height, oracle data proof and block relay proof */
export interface SingleProofAmino {
block_height?: string;
oracle_data_proof?: OracleDataProofAmino;
block_relay_proof?: BlockRelayProofAmino;
}
export interface SingleProofAminoMsg {
type: "/band.base.oracle.v1.SingleProof";
value: SingleProofAmino;
}
/** SingleProof contains block height, oracle data proof and block relay proof */
export interface SingleProofSDKType {
block_height: bigint;
oracle_data_proof: OracleDataProofSDKType;
block_relay_proof: BlockRelayProofSDKType;
}
/** MultiProof contains block height, list of oracle data proof and block relay proof */
export interface MultiProof {
blockHeight: bigint;
oracleDataMultiProof: OracleDataProof[];
blockRelayProof: BlockRelayProof;
}
export interface MultiProofProtoMsg {
typeUrl: "/band.base.oracle.v1.MultiProof";
value: Uint8Array;
}
/** MultiProof contains block height, list of oracle data proof and block relay proof */
export interface MultiProofAmino {
block_height?: string;
oracle_data_multi_proof?: OracleDataProofAmino[];
block_relay_proof?: BlockRelayProofAmino;
}
export interface MultiProofAminoMsg {
type: "/band.base.oracle.v1.MultiProof";
value: MultiProofAmino;
}
/** MultiProof contains block height, list of oracle data proof and block relay proof */
export interface MultiProofSDKType {
block_height: bigint;
oracle_data_multi_proof: OracleDataProofSDKType[];
block_relay_proof: BlockRelayProofSDKType;
}
/** CountProof contains block height, count proof and block relay proof */
export interface CountProof {
blockHeight: bigint;
countProof: RequestsCountProof;
blockRelayProof: BlockRelayProof;
}
export interface CountProofProtoMsg {
typeUrl: "/band.base.oracle.v1.CountProof";
value: Uint8Array;
}
/** CountProof contains block height, count proof and block relay proof */
export interface CountProofAmino {
block_height?: string;
count_proof?: RequestsCountProofAmino;
block_relay_proof?: BlockRelayProofAmino;
}
export interface CountProofAminoMsg {
type: "/band.base.oracle.v1.CountProof";
value: CountProofAmino;
}
/** CountProof contains block height, count proof and block relay proof */
export interface CountProofSDKType {
block_height: bigint;
count_proof: RequestsCountProofSDKType;
block_relay_proof: BlockRelayProofSDKType;
}
/** OracleDataProof contains result, version and merkle paths */
export interface OracleDataProof {
result: Result;
version: bigint;
merklePaths: IAVLMerklePath[];
}
export interface OracleDataProofProtoMsg {
typeUrl: "/band.base.oracle.v1.OracleDataProof";
value: Uint8Array;
}
/** OracleDataProof contains result, version and merkle paths */
export interface OracleDataProofAmino {
result?: ResultAmino;
version?: string;
merkle_paths?: IAVLMerklePathAmino[];
}
export interface OracleDataProofAminoMsg {
type: "/band.base.oracle.v1.OracleDataProof";
value: OracleDataProofAmino;
}
/** OracleDataProof contains result, version and merkle paths */
export interface OracleDataProofSDKType {
result: ResultSDKType;
version: bigint;
merkle_paths: IAVLMerklePathSDKType[];
}
/** IAVLMerklePath represents a Merkle step to a leaf data node in an iAVL tree. */
export interface IAVLMerklePath {
isDataOnRight: boolean;
subtreeHeight: number;
subtreeSize: bigint;
subtreeVersion: bigint;
siblingHash: Uint8Array;
}
export interface IAVLMerklePathProtoMsg {
typeUrl: "/band.base.oracle.v1.IAVLMerklePath";
value: Uint8Array;
}
/** IAVLMerklePath represents a Merkle step to a leaf data node in an iAVL tree. */
export interface IAVLMerklePathAmino {
is_data_on_right?: boolean;
subtree_height?: number;
subtree_size?: string;
subtree_version?: string;
sibling_hash?: string;
}
export interface IAVLMerklePathAminoMsg {
type: "/band.base.oracle.v1.IAVLMerklePath";
value: IAVLMerklePathAmino;
}
/** IAVLMerklePath represents a Merkle step to a leaf data node in an iAVL tree. */
export interface IAVLMerklePathSDKType {
is_data_on_right: boolean;
subtree_height: number;
subtree_size: bigint;
subtree_version: bigint;
sibling_hash: Uint8Array;
}
/** BlockRelayProof contains multi store proof, block header merkle parts, common encoded part and signatures */
export interface BlockRelayProof {
multiStoreProof: MultiStoreProof;
blockHeaderMerkleParts: BlockHeaderMerkleParts;
commonEncodedVotePart: CommonEncodedVotePart;
signatures: TMSignature[];
}
export interface BlockRelayProofProtoMsg {
typeUrl: "/band.base.oracle.v1.BlockRelayProof";
value: Uint8Array;
}
/** BlockRelayProof contains multi store proof, block header merkle parts, common encoded part and signatures */
export interface BlockRelayProofAmino {
multi_store_proof?: MultiStoreProofAmino;
block_header_merkle_parts?: BlockHeaderMerklePartsAmino;
common_encoded_vote_part?: CommonEncodedVotePartAmino;
signatures?: TMSignatureAmino[];
}
export interface BlockRelayProofAminoMsg {
type: "/band.base.oracle.v1.BlockRelayProof";
value: BlockRelayProofAmino;
}
/** BlockRelayProof contains multi store proof, block header merkle parts, common encoded part and signatures */
export interface BlockRelayProofSDKType {
multi_store_proof: MultiStoreProofSDKType;
block_header_merkle_parts: BlockHeaderMerklePartsSDKType;
common_encoded_vote_part: CommonEncodedVotePartSDKType;
signatures: TMSignatureSDKType[];
}
/**
* MultiStoreProof stores a compact of other Cosmos-SDK modules' storage hash in multistore to
* compute (in combination with oracle store hash) Tendermint's application state hash at a given block.
*
* __________________________[AppHash]__________________________
* / \
* ___________[N24]____________ ___________[N25]________
* / \ / \
* _____[N20]_____ ____[N21]______ ____[N22]______ _[N23]_
* / \ / \ / \ / \
* _[N12]_ _[N13]_ _[N14]_ _[N15]_ _[N16]_ _[N17]_ [N18] [Q]
* / \ / \ / \ / \ / \ / \ / \
* [N0] [N1] [N2] [N3] [N4] [N5] [N6] [N7] [N8] [N9] [N10] [N11] [O] [P]
* / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N]
*
* [0] - acc (auth) [1] - authz [2] - bandtss [3] - bank [4] - capability [5] - consensus
* [6] - crisis [7] - distribution [8] - evidence [9] - feeds [A] - feegrant [B] - feeibc
* [C] - globalfee [D] - gov [E] - ibc [F] - icahost [G] - mint [H] - oracle
* [I] - params [J] - restake [K] - rollingseed [L] - slashing [M] - staking [N] - transfer
* [O] - tss [P] - tunnel [Q] - upgrade
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [H] In fact, only
* [G], [N9], [N17], [N23], and [N24] are needed in order to compute [AppHash].
*/
export interface MultiStoreProof {
oracleIavlStateHash: Uint8Array;
mintStoreMerkleHash: Uint8Array;
paramsToRestakeStoresMerkleHash: Uint8Array;
rollingseedToTransferStoresMerkleHash: Uint8Array;
tssToUpgradeStoresMerkleHash: Uint8Array;
authToIcahostStoresMerkleHash: Uint8Array;
}
export interface MultiStoreProofProtoMsg {
typeUrl: "/band.base.oracle.v1.MultiStoreProof";
value: Uint8Array;
}
/**
* MultiStoreProof stores a compact of other Cosmos-SDK modules' storage hash in multistore to
* compute (in combination with oracle store hash) Tendermint's application state hash at a given block.
*
* __________________________[AppHash]__________________________
* / \
* ___________[N24]____________ ___________[N25]________
* / \ / \
* _____[N20]_____ ____[N21]______ ____[N22]______ _[N23]_
* / \ / \ / \ / \
* _[N12]_ _[N13]_ _[N14]_ _[N15]_ _[N16]_ _[N17]_ [N18] [Q]
* / \ / \ / \ / \ / \ / \ / \
* [N0] [N1] [N2] [N3] [N4] [N5] [N6] [N7] [N8] [N9] [N10] [N11] [O] [P]
* / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N]
*
* [0] - acc (auth) [1] - authz [2] - bandtss [3] - bank [4] - capability [5] - consensus
* [6] - crisis [7] - distribution [8] - evidence [9] - feeds [A] - feegrant [B] - feeibc
* [C] - globalfee [D] - gov [E] - ibc [F] - icahost [G] - mint [H] - oracle
* [I] - params [J] - restake [K] - rollingseed [L] - slashing [M] - staking [N] - transfer
* [O] - tss [P] - tunnel [Q] - upgrade
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [H] In fact, only
* [G], [N9], [N17], [N23], and [N24] are needed in order to compute [AppHash].
*/
export interface MultiStoreProofAmino {
oracle_iavl_state_hash?: string;
mint_store_merkle_hash?: string;
params_to_restake_stores_merkle_hash?: string;
rollingseed_to_transfer_stores_merkle_hash?: string;
tss_to_upgrade_stores_merkle_hash?: string;
auth_to_icahost_stores_merkle_hash?: string;
}
export interface MultiStoreProofAminoMsg {
type: "/band.base.oracle.v1.MultiStoreProof";
value: MultiStoreProofAmino;
}
/**
* MultiStoreProof stores a compact of other Cosmos-SDK modules' storage hash in multistore to
* compute (in combination with oracle store hash) Tendermint's application state hash at a given block.
*
* __________________________[AppHash]__________________________
* / \
* ___________[N24]____________ ___________[N25]________
* / \ / \
* _____[N20]_____ ____[N21]______ ____[N22]______ _[N23]_
* / \ / \ / \ / \
* _[N12]_ _[N13]_ _[N14]_ _[N15]_ _[N16]_ _[N17]_ [N18] [Q]
* / \ / \ / \ / \ / \ / \ / \
* [N0] [N1] [N2] [N3] [N4] [N5] [N6] [N7] [N8] [N9] [N10] [N11] [O] [P]
* / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N]
*
* [0] - acc (auth) [1] - authz [2] - bandtss [3] - bank [4] - capability [5] - consensus
* [6] - crisis [7] - distribution [8] - evidence [9] - feeds [A] - feegrant [B] - feeibc
* [C] - globalfee [D] - gov [E] - ibc [F] - icahost [G] - mint [H] - oracle
* [I] - params [J] - restake [K] - rollingseed [L] - slashing [M] - staking [N] - transfer
* [O] - tss [P] - tunnel [Q] - upgrade
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [H] In fact, only
* [G], [N9], [N17], [N23], and [N24] are needed in order to compute [AppHash].
*/
export interface MultiStoreProofSDKType {
oracle_iavl_state_hash: Uint8Array;
mint_store_merkle_hash: Uint8Array;
params_to_restake_stores_merkle_hash: Uint8Array;
rollingseed_to_transfer_stores_merkle_hash: Uint8Array;
tss_to_upgrade_stores_merkle_hash: Uint8Array;
auth_to_icahost_stores_merkle_hash: Uint8Array;
}
/**
* BlockHeaderMerkleParts stores a group of hashes using for computing Tendermint's block
* header hash from app hash, and height.
*
* In Tendermint, a block header hash is the Merkle hash of a binary tree with 14 leaf nodes.
* Each node encodes a data piece of the blockchain. The notable data leaves are: [A] app_hash,
* [2] height. All data pieces are combined into one 32-byte hash to be signed
* by block validators. The structure of the Merkle tree is shown below.
*
* [BlockHeader]
* / \
* [3A] [3B]
* / \ / \
* [2A] [2B] [2C] [2D]
* / \ / \ / \ / \
* [1A] [1B] [1C] [1D] [1E] [1F] [C] [D]
* / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B]
*
* [0] - version [1] - chain_id [2] - height [3] - time
* [4] - last_block_id [5] - last_commit_hash [6] - data_hash [7] - validators_hash
* [8] - next_validators_hash [9] - consensus_hash [A] - app_hash [B] - last_results_hash
* [C] - evidence_hash [D] - proposer_address
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [2], [3], and [A]. In fact, only
* [1A], [2B], [1E], [B], and [2D] are needed in order to compute [BlockHeader].
*/
export interface BlockHeaderMerkleParts {
versionAndChainIdHash: Uint8Array;
height: bigint;
timeSecond: bigint;
timeNanoSecond: number;
lastBlockIdAndOther: Uint8Array;
nextValidatorHashAndConsensusHash: Uint8Array;
lastResultsHash: Uint8Array;
evidenceAndProposerHash: Uint8Array;
}
export interface BlockHeaderMerklePartsProtoMsg {
typeUrl: "/band.base.oracle.v1.BlockHeaderMerkleParts";
value: Uint8Array;
}
/**
* BlockHeaderMerkleParts stores a group of hashes using for computing Tendermint's block
* header hash from app hash, and height.
*
* In Tendermint, a block header hash is the Merkle hash of a binary tree with 14 leaf nodes.
* Each node encodes a data piece of the blockchain. The notable data leaves are: [A] app_hash,
* [2] height. All data pieces are combined into one 32-byte hash to be signed
* by block validators. The structure of the Merkle tree is shown below.
*
* [BlockHeader]
* / \
* [3A] [3B]
* / \ / \
* [2A] [2B] [2C] [2D]
* / \ / \ / \ / \
* [1A] [1B] [1C] [1D] [1E] [1F] [C] [D]
* / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B]
*
* [0] - version [1] - chain_id [2] - height [3] - time
* [4] - last_block_id [5] - last_commit_hash [6] - data_hash [7] - validators_hash
* [8] - next_validators_hash [9] - consensus_hash [A] - app_hash [B] - last_results_hash
* [C] - evidence_hash [D] - proposer_address
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [2], [3], and [A]. In fact, only
* [1A], [2B], [1E], [B], and [2D] are needed in order to compute [BlockHeader].
*/
export interface BlockHeaderMerklePartsAmino {
version_and_chain_id_hash?: string;
height?: string;
time_second?: string;
time_nano_second?: number;
last_block_id_and_other?: string;
next_validator_hash_and_consensus_hash?: string;
last_results_hash?: string;
evidence_and_proposer_hash?: string;
}
export interface BlockHeaderMerklePartsAminoMsg {
type: "/band.base.oracle.v1.BlockHeaderMerkleParts";
value: BlockHeaderMerklePartsAmino;
}
/**
* BlockHeaderMerkleParts stores a group of hashes using for computing Tendermint's block
* header hash from app hash, and height.
*
* In Tendermint, a block header hash is the Merkle hash of a binary tree with 14 leaf nodes.
* Each node encodes a data piece of the blockchain. The notable data leaves are: [A] app_hash,
* [2] height. All data pieces are combined into one 32-byte hash to be signed
* by block validators. The structure of the Merkle tree is shown below.
*
* [BlockHeader]
* / \
* [3A] [3B]
* / \ / \
* [2A] [2B] [2C] [2D]
* / \ / \ / \ / \
* [1A] [1B] [1C] [1D] [1E] [1F] [C] [D]
* / \ / \ / \ / \ / \ / \
* [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [A] [B]
*
* [0] - version [1] - chain_id [2] - height [3] - time
* [4] - last_block_id [5] - last_commit_hash [6] - data_hash [7] - validators_hash
* [8] - next_validators_hash [9] - consensus_hash [A] - app_hash [B] - last_results_hash
* [C] - evidence_hash [D] - proposer_address
*
* Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
* root hash, since we only want to validate the correctness of [2], [3], and [A]. In fact, only
* [1A], [2B], [1E], [B], and [2D] are needed in order to compute [BlockHeader].
*/
export interface BlockHeaderMerklePartsSDKType {
version_and_chain_id_hash: Uint8Array;
height: bigint;
time_second: bigint;
time_nano_second: number;
last_block_id_and_other: Uint8Array;
next_validator_hash_and_consensus_hash: Uint8Array;
last_results_hash: Uint8Array;
evidence_and_proposer_hash: Uint8Array;
}
/** CommonEncodedVotePart represents the common part of encoded vote */
export interface CommonEncodedVotePart {
signedDataPrefix: Uint8Array;
signedDataSuffix: Uint8Array;
}
export interface CommonEncodedVotePartProtoMsg {
typeUrl: "/band.base.oracle.v1.CommonEncodedVotePart";
value: Uint8Array;
}
/** CommonEncodedVotePart represents the common part of encoded vote */
export interface CommonEncodedVotePartAmino {
signed_data_prefix?: string;
signed_data_suffix?: string;
}
export interface CommonEncodedVotePartAminoMsg {
type: "/band.base.oracle.v1.CommonEncodedVotePart";
value: CommonEncodedVotePartAmino;
}
/** CommonEncodedVotePart represents the common part of encoded vote */
export interface CommonEncodedVotePartSDKType {
signed_data_prefix: Uint8Array;
signed_data_suffix: Uint8Array;
}
/**
* TMSignature contains all details of validator signature for performing signer recovery for ECDSA
* secp256k1 signature. Note that this struct is written specifically for signature signed on
* Tendermint's precommit data, which includes the block hash and some additional information prepended
* and appended to the block hash. The prepended part (prefix) and the appended part (suffix) are
* different for each signer (including signature size, machine clock, validator index, etc).
*/
export interface TMSignature {
r: Uint8Array;
s: Uint8Array;
v: number;
encodedTimestamp: Uint8Array;
}
export interface TMSignatureProtoMsg {
typeUrl: "/band.base.oracle.v1.TMSignature";
value: Uint8Array;
}
/**
* TMSignature contains all details of validator signature for performing signer recovery for ECDSA
* secp256k1 signature. Note that this struct is written specifically for signature signed on
* Tendermint's precommit data, which includes the block hash and some additional information prepended
* and appended to the block hash. The prepended part (prefix) and the appended part (suffix) are
* different for each signer (including signature size, machine clock, validator index, etc).
*/
export interface TMSignatureAmino {
r?: string;
s?: string;
v?: number;
encoded_timestamp?: string;
}
export interface TMSignatureAminoMsg {
type: "/band.base.oracle.v1.TMSignature";
value: TMSignatureAmino;
}
/**
* TMSignature contains all details of validator signature for performing signer recovery for ECDSA
* secp256k1 signature. Note that this struct is written specifically for signature signed on
* Tendermint's precommit data, which includes the block hash and some additional information prepended
* and appended to the block hash. The prepended part (prefix) and the appended part (suffix) are
* different for each signer (including signature size, machine clock, validator index, etc).
*/
export interface TMSignatureSDKType {
r: Uint8Array;
s: Uint8Array;
v: number;
encoded_timestamp: Uint8Array;
}
/** RequestsCountProof contains count, version and merkle paths */
export interface RequestsCountProof {
count: bigint;
version: bigint;
merklePaths: IAVLMerklePath[];
}
export interface RequestsCountProofProtoMsg {
typeUrl: "/band.base.oracle.v1.RequestsCountProof";
value: Uint8Array;
}
/** RequestsCountProof contains count, version and merkle paths */
export interface RequestsCountProofAmino {
count?: string;
version?: string;
merkle_paths?: IAVLMerklePathAmino[];
}
export interface RequestsCountProofAminoMsg {
type: "/band.base.oracle.v1.RequestsCountProof";
value: RequestsCountProofAmino;
}
/** RequestsCountProof contains count, version and merkle paths */
export interface RequestsCountProofSDKType {
count: bigint;
version: bigint;
merkle_paths: IAVLMerklePathSDKType[];
}
export declare const ProofRequest: {
typeUrl: string;
encode(message: ProofRequest, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): ProofRequest;
fromPartial(object: Partial<ProofRequest>): ProofRequest;
fromAmino(object: ProofRequestAmino): ProofRequest;
toAmino(message: ProofRequest): ProofRequestAmino;
fromAminoMsg(object: ProofRequestAminoMsg): ProofRequest;
fromProtoMsg(message: ProofRequestProtoMsg): ProofRequest;
toProto(message: ProofRequest): Uint8Array;
toProtoMsg(message: ProofRequest): ProofRequestProtoMsg;
};
export declare const ProofResponse: {
typeUrl: string;
encode(message: ProofResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): ProofResponse;
fromPartial(object: Partial<ProofResponse>): ProofResponse;
fromAmino(object: ProofResponseAmino): ProofResponse;
toAmino(message: ProofResponse): ProofResponseAmino;
fromAminoMsg(object: ProofResponseAminoMsg): ProofResponse;
fromProtoMsg(message: ProofResponseProtoMsg): ProofResponse;
toProto(message: ProofResponse): Uint8Array;
toProtoMsg(message: ProofResponse): ProofResponseProtoMsg;
};
export declare const MultiProofRequest: {
typeUrl: string;
encode(message: MultiProofRequest, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MultiProofRequest;
fromPartial(object: Partial<MultiProofRequest>): MultiProofRequest;
fromAmino(object: MultiProofRequestAmino): MultiProofRequest;
toAmino(message: MultiProofRequest): MultiProofRequestAmino;
fromAminoMsg(object: MultiProofRequestAminoMsg): MultiProofRequest;
fromProtoMsg(message: MultiProofRequestProtoMsg): MultiProofRequest;
toProto(message: MultiProofRequest): Uint8Array;
toProtoMsg(message: MultiProofRequest): MultiProofRequestProtoMsg;
};
export declare const MultiProofResponse: {
typeUrl: string;
encode(message: MultiProofResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MultiProofResponse;
fromPartial(object: Partial<MultiProofResponse>): MultiProofResponse;
fromAmino(object: MultiProofResponseAmino): MultiProofResponse;
toAmino(message: MultiProofResponse): MultiProofResponseAmino;
fromAminoMsg(object: MultiProofResponseAminoMsg): MultiProofResponse;
fromProtoMsg(message: MultiProofResponseProtoMsg): MultiProofResponse;
toProto(message: MultiProofResponse): Uint8Array;
toProtoMsg(message: MultiProofResponse): MultiProofResponseProtoMsg;
};
export declare const RequestCountProofRequest: {
typeUrl: string;
encode(_: RequestCountProofRequest, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): RequestCountProofRequest;
fromPartial(_: Partial<RequestCountProofRequest>): RequestCountProofRequest;
fromAmino(_: RequestCountProofRequestAmino): RequestCountProofRequest;
toAmino(_: RequestCountProofRequest): RequestCountProofRequestAmino;
fromAminoMsg(object: RequestCountProofRequestAminoMsg): RequestCountProofRequest;
fromProtoMsg(message: RequestCountProofRequestProtoMsg): RequestCountProofRequest;
toProto(message: RequestCountProofRequest): Uint8Array;
toProtoMsg(message: RequestCountProofRequest): RequestCountProofRequestProtoMsg;
};
export declare const RequestCountProofResponse: {
typeUrl: string;
encode(message: RequestCountProofResponse, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): RequestCountProofResponse;
fromPartial(object: Partial<RequestCountProofResponse>): RequestCountProofResponse;
fromAmino(object: RequestCountProofResponseAmino): RequestCountProofResponse;
toAmino(message: RequestCountProofResponse): RequestCountProofResponseAmino;
fromAminoMsg(object: RequestCountProofResponseAminoMsg): RequestCountProofResponse;
fromProtoMsg(message: RequestCountProofResponseProtoMsg): RequestCountProofResponse;
toProto(message: RequestCountProofResponse): Uint8Array;
toProtoMsg(message: RequestCountProofResponse): RequestCountProofResponseProtoMsg;
};
export declare const SingleProofResult: {
typeUrl: string;
encode(message: SingleProofResult, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): SingleProofResult;
fromPartial(object: Partial<SingleProofResult>): SingleProofResult;
fromAmino(object: SingleProofResultAmino): SingleProofResult;
toAmino(message: SingleProofResult): SingleProofResultAmino;
fromAminoMsg(object: SingleProofResultAminoMsg): SingleProofResult;
fromProtoMsg(message: SingleProofResultProtoMsg): SingleProofResult;
toProto(message: SingleProofResult): Uint8Array;
toProtoMsg(message: SingleProofResult): SingleProofResultProtoMsg;
};
export declare const MultiProofResult: {
typeUrl: string;
encode(message: MultiProofResult, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MultiProofResult;
fromPartial(object: Partial<MultiProofResult>): MultiProofResult;
fromAmino(object: MultiProofResultAmino): MultiProofResult;
toAmino(message: MultiProofResult): MultiProofResultAmino;
fromAminoMsg(object: MultiProofResultAminoMsg): MultiProofResult;
fromProtoMsg(message: MultiProofResultProtoMsg): MultiProofResult;
toProto(message: MultiProofResult): Uint8Array;
toProtoMsg(message: MultiProofResult): MultiProofResultProtoMsg;
};
export declare const CountProofResult: {
typeUrl: string;
encode(message: CountProofResult, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): CountProofResult;
fromPartial(object: Partial<CountProofResult>): CountProofResult;
fromAmino(object: CountProofResultAmino): CountProofResult;
toAmino(message: CountProofResult): CountProofResultAmino;
fromAminoMsg(object: CountProofResultAminoMsg): CountProofResult;
fromProtoMsg(message: CountProofResultProtoMsg): CountProofResult;
toProto(message: CountProofResult): Uint8Array;
toProtoMsg(message: CountProofResult): CountProofResultProtoMsg;
};
export declare const SingleProof: {
typeUrl: string;
encode(message: SingleProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): SingleProof;
fromPartial(object: Partial<SingleProof>): SingleProof;
fromAmino(object: SingleProofAmino): SingleProof;
toAmino(message: SingleProof): SingleProofAmino;
fromAminoMsg(object: SingleProofAminoMsg): SingleProof;
fromProtoMsg(message: SingleProofProtoMsg): SingleProof;
toProto(message: SingleProof): Uint8Array;
toProtoMsg(message: SingleProof): SingleProofProtoMsg;
};
export declare const MultiProof: {
typeUrl: string;
encode(message: MultiProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MultiProof;
fromPartial(object: Partial<MultiProof>): MultiProof;
fromAmino(object: MultiProofAmino): MultiProof;
toAmino(message: MultiProof): MultiProofAmino;
fromAminoMsg(object: MultiProofAminoMsg): MultiProof;
fromProtoMsg(message: MultiProofProtoMsg): MultiProof;
toProto(message: MultiProof): Uint8Array;
toProtoMsg(message: MultiProof): MultiProofProtoMsg;
};
export declare const CountProof: {
typeUrl: string;
encode(message: CountProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): CountProof;
fromPartial(object: Partial<CountProof>): CountProof;
fromAmino(object: CountProofAmino): CountProof;
toAmino(message: CountProof): CountProofAmino;
fromAminoMsg(object: CountProofAminoMsg): CountProof;
fromProtoMsg(message: CountProofProtoMsg): CountProof;
toProto(message: CountProof): Uint8Array;
toProtoMsg(message: CountProof): CountProofProtoMsg;
};
export declare const OracleDataProof: {
typeUrl: string;
encode(message: OracleDataProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): OracleDataProof;
fromPartial(object: Partial<OracleDataProof>): OracleDataProof;
fromAmino(object: OracleDataProofAmino): OracleDataProof;
toAmino(message: OracleDataProof): OracleDataProofAmino;
fromAminoMsg(object: OracleDataProofAminoMsg): OracleDataProof;
fromProtoMsg(message: OracleDataProofProtoMsg): OracleDataProof;
toProto(message: OracleDataProof): Uint8Array;
toProtoMsg(message: OracleDataProof): OracleDataProofProtoMsg;
};
export declare const IAVLMerklePath: {
typeUrl: string;
encode(message: IAVLMerklePath, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): IAVLMerklePath;
fromPartial(object: Partial<IAVLMerklePath>): IAVLMerklePath;
fromAmino(object: IAVLMerklePathAmino): IAVLMerklePath;
toAmino(message: IAVLMerklePath): IAVLMerklePathAmino;
fromAminoMsg(object: IAVLMerklePathAminoMsg): IAVLMerklePath;
fromProtoMsg(message: IAVLMerklePathProtoMsg): IAVLMerklePath;
toProto(message: IAVLMerklePath): Uint8Array;
toProtoMsg(message: IAVLMerklePath): IAVLMerklePathProtoMsg;
};
export declare const BlockRelayProof: {
typeUrl: string;
encode(message: BlockRelayProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): BlockRelayProof;
fromPartial(object: Partial<BlockRelayProof>): BlockRelayProof;
fromAmino(object: BlockRelayProofAmino): BlockRelayProof;
toAmino(message: BlockRelayProof): BlockRelayProofAmino;
fromAminoMsg(object: BlockRelayProofAminoMsg): BlockRelayProof;
fromProtoMsg(message: BlockRelayProofProtoMsg): BlockRelayProof;
toProto(message: BlockRelayProof): Uint8Array;
toProtoMsg(message: BlockRelayProof): BlockRelayProofProtoMsg;
};
export declare const MultiStoreProof: {
typeUrl: string;
encode(message: MultiStoreProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): MultiStoreProof;
fromPartial(object: Partial<MultiStoreProof>): MultiStoreProof;
fromAmino(object: MultiStoreProofAmino): MultiStoreProof;
toAmino(message: MultiStoreProof): MultiStoreProofAmino;
fromAminoMsg(object: MultiStoreProofAminoMsg): MultiStoreProof;
fromProtoMsg(message: MultiStoreProofProtoMsg): MultiStoreProof;
toProto(message: MultiStoreProof): Uint8Array;
toProtoMsg(message: MultiStoreProof): MultiStoreProofProtoMsg;
};
export declare const BlockHeaderMerkleParts: {
typeUrl: string;
encode(message: BlockHeaderMerkleParts, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): BlockHeaderMerkleParts;
fromPartial(object: Partial<BlockHeaderMerkleParts>): BlockHeaderMerkleParts;
fromAmino(object: BlockHeaderMerklePartsAmino): BlockHeaderMerkleParts;
toAmino(message: BlockHeaderMerkleParts): BlockHeaderMerklePartsAmino;
fromAminoMsg(object: BlockHeaderMerklePartsAminoMsg): BlockHeaderMerkleParts;
fromProtoMsg(message: BlockHeaderMerklePartsProtoMsg): BlockHeaderMerkleParts;
toProto(message: BlockHeaderMerkleParts): Uint8Array;
toProtoMsg(message: BlockHeaderMerkleParts): BlockHeaderMerklePartsProtoMsg;
};
export declare const CommonEncodedVotePart: {
typeUrl: string;
encode(message: CommonEncodedVotePart, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): CommonEncodedVotePart;
fromPartial(object: Partial<CommonEncodedVotePart>): CommonEncodedVotePart;
fromAmino(object: CommonEncodedVotePartAmino): CommonEncodedVotePart;
toAmino(message: CommonEncodedVotePart): CommonEncodedVotePartAmino;
fromAminoMsg(object: CommonEncodedVotePartAminoMsg): CommonEncodedVotePart;
fromProtoMsg(message: CommonEncodedVotePartProtoMsg): CommonEncodedVotePart;
toProto(message: CommonEncodedVotePart): Uint8Array;
toProtoMsg(message: CommonEncodedVotePart): CommonEncodedVotePartProtoMsg;
};
export declare const TMSignature: {
typeUrl: string;
encode(message: TMSignature, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): TMSignature;
fromPartial(object: Partial<TMSignature>): TMSignature;
fromAmino(object: TMSignatureAmino): TMSignature;
toAmino(message: TMSignature): TMSignatureAmino;
fromAminoMsg(object: TMSignatureAminoMsg): TMSignature;
fromProtoMsg(message: TMSignatureProtoMsg): TMSignature;
toProto(message: TMSignature): Uint8Array;
toProtoMsg(message: TMSignature): TMSignatureProtoMsg;
};
export declare const RequestsCountProof: {
typeUrl: string;
encode(message: RequestsCountProof, writer?: BinaryWriter): BinaryWriter;
decode(input: BinaryReader | Uint8Array, length?: number): RequestsCountProof;
fromPartial(object: Partial<RequestsCountProof>): RequestsCountProof;
fromAmino(object: RequestsCountProofAmino): RequestsCountProof;
toAmino(message: RequestsCountProof): RequestsCountProofAmino;
fromAminoMsg(object: RequestsCountProofAminoMsg): RequestsCountProof;
fromProtoMsg(message: RequestsCountProofProtoMsg): RequestsCountProof;
toProto(message: RequestsCountProof): Uint8Array;
toProtoMsg(message: RequestsCountProof): RequestsCountProofProtoMsg;
};