Struct MasternodeProtocolVote

pub struct MasternodeProtocolVote {
    pub pro_tx_hash: ProTxHash,
    pub voted_version: u32,
}

Vote of a masternode for a protocol version.

Fields

pro_tx_hash: ProTxHash

ProTxHash of the masternode

voted_version: u32

Version for which this masternode voted

Trait Implementations

impl Debug for MasternodeProtocolVote

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MasternodeProtocolVote

fn deserialize<__D>( __deserializer: __D, ) -> Result<MasternodeProtocolVote, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FetchMany<ProTxHash, IndexMap<ProTxHash, Option<MasternodeProtocolVote>>> for MasternodeProtocolVote

Fetch information about protocol version upgrade voted by each node.

Returns list of MasternodeProtocolVotes indexed by ProTxHash. Each item in this list represents node protxhash and its preferred protocol version.

Supported query types

• ProTxHash - proTxHash of first object to find; will return up to DEFAULT_NODES_VOTING_LIMIT objects
• Option<ProTxHash> - proTxHash that can be and Option; if it is None, the query will return all objects
• LimitQuery<ProTxHash> - limit query that allows to specify maximum number of objects to fetch; see also FetchMany::fetch_many_with_limit().

type Request = GetProtocolVersionUpgradeVoteStatusRequest

Type of request used to fetch multiple objects from Platform.

fn fetch_many<'life0, 'async_trait, Q>( sdk: &'life0 Sdk, query: Q, ) -> Pin<Box<dyn Future<Output = Result<O, Error>> + Send + 'async_trait>>

where Q: 'async_trait + Query<<Self as FetchMany<K, O>>::Request>, Self: Send + 'async_trait, 'life0: 'async_trait,

Fetch (or search) multiple objects on the Dash Platform

fn fetch_many_with_metadata<'life0, 'async_trait, Q>( sdk: &'life0 Sdk, query: Q, settings: Option<RequestSettings>, ) -> Pin<Box<dyn Future<Output = Result<(O, ResponseMetadata), Error>> + Send + 'async_trait>>

where Q: 'async_trait + Query<<Self as FetchMany<K, O>>::Request>, Self: Send + 'async_trait, 'life0: 'async_trait,

Fetch multiple objects from Platform with metadata.

fn fetch_many_with_metadata_and_proof<'life0, 'async_trait, Q>( sdk: &'life0 Sdk, query: Q, settings: Option<RequestSettings>, ) -> Pin<Box<dyn Future<Output = Result<(O, ResponseMetadata, Proof), Error>> + Send + 'async_trait>>

where Q: 'async_trait + Query<<Self as FetchMany<K, O>>::Request>, Self: Send + 'async_trait, 'life0: 'async_trait,

Fetch multiple objects from Platform with metadata and underlying proof.

fn fetch_many_with_limit<'life0, 'async_trait, Q>( sdk: &'life0 Sdk, query: Q, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<O, Error>> + Send + 'async_trait>>

where LimitQuery<Q>: Query<<Self as FetchMany<K, O>>::Request>, Q: 'async_trait + Query<<Self as FetchMany<K, O>>::Request>, Self: Send + 'async_trait, 'life0: 'async_trait,

Fetch multiple objects from Platform with limit.

impl MasternodeProtocolVoteEx<ProTxHash> for MasternodeProtocolVote

fn fetch_votes<'life0, 'async_trait>( sdk: &'life0 Sdk, start_protxhash: Option<ProTxHash>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<MasternodeProtocolVotes, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch masternode votes for version update from Platform.

impl MockResponse for MasternodeProtocolVote

fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8>

Serialize the object to save into expectations

fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self

where Self: Sized,

Deserialize the object from expectations

impl PlatformVersionEncode for MasternodeProtocolVote

fn platform_encode<E>( &self, encoder: &mut E, platform_version: &PlatformVersion, ) -> Result<(), EncodeError>

where E: Encoder,

Encode a given type.

impl PlatformVersionedDecode for MasternodeProtocolVote

fn platform_versioned_decode<D>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<MasternodeProtocolVote, DecodeError>

where D: Decoder,

Attempt to decode this type with the given Decode.

impl Serialize for MasternodeProtocolVote

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.