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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; fromAmino(object: RequestsCountProofAmino): RequestsCountProof; toAmino(message: RequestsCountProof): RequestsCountProofAmino; fromAminoMsg(object: RequestsCountProofAminoMsg): RequestsCountProof; fromProtoMsg(message: RequestsCountProofProtoMsg): RequestsCountProof; toProto(message: RequestsCountProof): Uint8Array; toProtoMsg(message: RequestsCountProof): RequestsCountProofProtoMsg; };