Struct RandomnessBeaconObject

pub struct RandomnessBeaconObject {

    pub id: SharedObjectId,
    pub validators: HashMap<String, BeaconValidator>,
    pub rounds: HashMap<u64, BeaconRound>,
    pub current_round: u64,
    pub round_duration_secs: u64,
    pub last_round_time: DateTime<Utc>,
    pub pending_vrf_proofs: HashMap<u64, Vec<VrfProof>>,
    pub pending_partial_sigs: HashMap<u64, HashMap<String, String>>,
    pub threshold: u64,
    pub my_validator_address: String,
    pub signer: ECDSASigner,
    pub verifier: ECDSAVerifier,
    pub messages: Vec<BeaconMessageType>,
    pub bias_resistance_enabled: bool,
    pub challenges: HashMap<u64, Vec<BeaconMessageType>>,
}

Randomness beacon implementation

Fields

id: SharedObjectId

validators: HashMap<String, BeaconValidator>

rounds: HashMap<u64, BeaconRound>

current_round: u64

round_duration_secs: u64

last_round_time: DateTime<Utc>

pending_vrf_proofs: HashMap<u64, Vec<VrfProof>>

pending_partial_sigs: HashMap<u64, HashMap<String, String>>

threshold: u64

my_validator_address: String

signer: ECDSASigner

verifier: ECDSAVerifier

messages: Vec<BeaconMessageType>

bias_resistance_enabled: bool

challenges: HashMap<u64, Vec<BeaconMessageType>>

Implementations

impl RandomnessBeaconObject

pub fn new(round_duration_secs: u64, threshold: u64) -> Result<Self>

pub fn register_validator(&mut self, validator: BeaconValidator) -> Result<()>

Register a validator for beacon participation

pub fn should_advance_round(&self) -> bool

Check if enough time has passed to advance to next round

pub fn generate_vrf_proof(&self, input: &str) -> Result<VrfProof>

Generate VRF proof for current round

pub fn process_vrf_proof(&mut self, msg: BeaconMessageType) -> Result<bool>

Process VRF proof submission

pub fn process_partial_signature( &mut self, msg: BeaconMessageType, ) -> Result<bool>

Process partial signature

pub fn can_finalize_round(&self) -> bool

Check if we can finalize the current round

pub fn finalize_round(&mut self) -> Result<String>

Finalize the current round and generate randomness

pub fn process_bias_challenge(&mut self, msg: BeaconMessageType) -> Result<bool>

Process bias challenge

pub fn get_beacon_stats(&self) -> Value

Get beacon statistics

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

Get latest randomness

pub fn get_randomness_history(&self, count: usize) -> Vec<(u64, String)>

Get randomness history

Trait Implementations

impl ApplicationObject for RandomnessBeaconObject

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 RandomnessBeaconObject

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

Formats the value using the given formatter.