Struct Round 

pub struct Round {

    pub discriminator: [u8; 8],
    pub version: u16,
    pub bump: u8,
    pub id: u32,
    pub state: RoundState,
    pub blockhash_entropy: [u8; 32],
    pub winning_tile: Option<u8>,
    pub deployed_pending_usd_amount: u64,
    pub deployed_usd_amount: u64,
    pub deployed_btc_amount: u64,
    pub deployed_usd_on_winning_tile_amount: u64,
    pub miners_count: u32,
    pub revealed_miners_count: u32,
    pub winners_count: u32,
    pub settled_miners_count: u32,
    pub strike_bonus_usd: u64,
    pub strike_bonus_btc: u64,
    pub public_tile_stakes: [TileStake; 21],
    pub deploy_entropy_acc: [u8; 32],
    pub settled_at_slot: u64,
    pub pending_epoch_fee_usd_amount: u64,
    pub pending_one_btc_fee_usd_amount: u64,
    pub pending_protocol_fee_usd_amount: u64,
    pub reserved: [u8; 40],
}

Fields

discriminator: [u8; 8]

version: u16

Struct version.

bump: u8

PDA bump seed.

id: u32

Sequential round identifier.

state: RoundState

Round state

blockhash_entropy: [u8; 32]

Raw blockhash entropy, read from the SlotHashes sysvar at reveal.

winning_tile: Option<u8>

Winning tile index, revealed upon settlement

deployed_pending_usd_amount: u64

Total net USD deployed into the round before the USD->BTC swap

deployed_usd_amount: u64

Total net USD stake after USD->BTC swap

deployed_btc_amount: u64

Total net BTC stake after USD->BTC swap

deployed_usd_on_winning_tile_amount: u64

Total net USD placed on the winning tile

miners_count: u32

Total amount of players in the round

revealed_miners_count: u32

Number of miners whose selection is revealed.

winners_count: u32

Total amount of winners, revealed during settlement

settled_miners_count: u32

Total amount of miners who claimed their winnings/hashrate, should equal to miners_count

strike_bonus_usd: u64

Strike jackpot USD rolled into this round on trigger, distributed to winners.

strike_bonus_btc: u64

Strike jackpot BTC rolled into this round on trigger, distributed to winners.

public_tile_stakes: [TileStake; 21]

Per-tile deploy count and stake sum, accumulated as public miners deploy. Indexed by tile (0..TILES_COUNT). Read at reveal to derive the winning tile’s totals without a per-deployment settlement pass.

deploy_entropy_acc: [u8; 32]

Running hash-chain accumulator of every public deploy.

settled_at_slot: u64

Slot at which the round reached Settled state.

pending_epoch_fee_usd_amount: u64

Epoch Vault fee accrued by this round’s deploys, in USD base units. Physically sits in the board’s USD pool until swept at rotation.

pending_one_btc_fee_usd_amount: u64

1 BTC Vault fee accrued by this round’s deploys; same lifecycle.

pending_protocol_fee_usd_amount: u64

Protocol (treasury) fee accrued by this round’s deploys; same lifecycle.

reserved: [u8; 40]

Reserved.

Implementations

impl Round

pub fn from_bytes(data: &[u8]) -> Result<Self, Error>

Trait Implementations

impl BorshDeserialize for Round

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Round

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for Round

fn clone(&self) -> Round

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Round

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

Formats the value using the given formatter.

impl Eq for Round

impl PartialEq for Round

fn eq(&self, other: &Round) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Round

impl<'a> TryFrom<&AccountInfo<'a>> for Round

type Error = Error

The type returned in the event of a conversion error.

fn try_from(account_info: &AccountInfo<'a>) -> Result<Self, Self::Error>

Performs the conversion.