Struct TendermintObject

pub struct TendermintObject {

    pub id: SharedObjectId,
    pub validators: HashMap<String, ValidatorInfo>,
    pub blocks: Vec<Block>,
    pub current_height: u64,
    pub current_round: u32,
    pub state: ConsensusState,
    pub proposals: HashMap<(u64, u32), TendermintMessageType>,
    pub prevotes: HashMap<(u64, u32), HashMap<String, Vote>>,
    pub precommits: HashMap<(u64, u32), HashMap<String, Vote>>,
    pub locked_block: Option<String>,
    pub locked_round: Option<u32>,
    pub my_validator_address: String,
    pub signer: ECDSASigner,
    pub verifier: ECDSAVerifier,
    pub messages: Vec<TendermintMessageType>,
}

Tendermint BFT consensus object

Fields

id: SharedObjectId

validators: HashMap<String, ValidatorInfo>

blocks: Vec<Block>

current_height: u64

current_round: u32

state: ConsensusState

proposals: HashMap<(u64, u32), TendermintMessageType>

prevotes: HashMap<(u64, u32), HashMap<String, Vote>>

precommits: HashMap<(u64, u32), HashMap<String, Vote>>

locked_block: Option<String>

locked_round: Option<u32>

my_validator_address: String

signer: ECDSASigner

verifier: ECDSAVerifier

messages: Vec<TendermintMessageType>

Implementations

impl TendermintObject

pub fn new() -> Result<Self>

pub fn add_validator( &mut self, address: String, public_key: String, voting_power: u64, )

Add a validator to the set

pub fn total_voting_power(&self) -> u64

Get total voting power of active validators

pub fn has_majority(&self, voting_power: u64) -> bool

Check if we have +2/3 majority

pub fn process_proposal( &mut self, proposal: TendermintMessageType, ) -> Result<bool>

Process a proposal message

pub fn process_prevote( &mut self, prevote: TendermintMessageType, ) -> Result<bool>

Process a prevote message

pub fn process_precommit( &mut self, precommit: TendermintMessageType, ) -> Result<bool>

Process a precommit message

pub fn can_commit(&self) -> Option<String>

Check if we can commit a block

pub fn commit_block(&mut self, block_hash: String) -> Result<()>

Commit a block

pub fn create_proposal( &self, transactions: Vec<Value>, ) -> Result<TendermintMessageType>

Create a proposal for the current height/round

pub fn get_consensus_info(&self) -> Value

Get current consensus state info

pub fn get_voting_stats(&self) -> Value

Get voting statistics for current round

Trait Implementations

impl ApplicationObject for TendermintObject

fn id(&self) -> &SharedObjectId

Get the object’s unique identifier

fn type_name(&self) -> &'static str

Get the object’s type name

fn is_valid<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 SharedMessage, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Validate if a message is valid for this object

fn add_message<'life0, 'async_trait>( &'life0 mut self, message: SharedMessage, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Add a validated message to the object

fn is_merkleized(&self) -> bool

Check if this object supports merkleized synchronization

fn get_latest_digest<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

Get the latest state digest

fn has_digest<'life0, 'life1, 'async_trait>( &'life0 self, digest: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Check if object has a specific digest

fn is_valid_digest<'life0, 'life1, 'async_trait>( &'life0 self, _digest: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Validate if a digest is valid

fn add_digest<'life0, 'async_trait>( &'life0 mut self, _digest: String, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Add a digest to the object

fn gossip_messages<'life0, 'life1, 'async_trait>( &'life0 self, _digest: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<SharedMessage>>> + Send + 'async_trait>>

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

Get messages for gossip protocol

fn get_messages_since_digest<'life0, 'life1, 'async_trait>( &'life0 self, _digest: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<SharedMessage>>> + Send + 'async_trait>>

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

Get messages since a specific digest

fn get_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

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

Get the current state as JSON

fn reset<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Reset the object to initial state

fn clone_box(&self) -> Box<dyn ApplicationObject>

Clone the object

fn as_any(&self) -> &dyn Any

Get reference as Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get mutable reference as Any for downcasting

impl Debug for TendermintObject

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

Formats the value using the given formatter.