Struct round::state::Round

pub struct Round {

    pub status: RoundStatus,
    pub bid_mint: Pubkey,
    pub offer_mint: Pubkey,
    pub heir: Pubkey,
    pub recipient: Pubkey,
    pub payer: Pubkey,
    pub vouchers_count: u64,
    pub created_at: i64,
    pub bidding_start: i64,
    pub bidding_end: i64,
    pub total_bid: Option<u64>,
    pub total_offer: Option<u64>,
    pub target_bid: u64,
    pub return_wallet: Pubkey,
    pub reserved1: [u8; 24],
    pub reserved2: Pubkey,
    pub reserved3: Pubkey,
}

Fields

status: RoundStatus

current offer status

bid_mint: Pubkey

users offering token (typically wSOL) this is embedded in the account to avoid extra lookups and emit it in events

offer_mint: Pubkey

creator offering token

heir: Pubkey

account that can accept/reject bid

recipient: Pubkey

account that receives bid in case of accept

payer: Pubkey

account to refund SOL from closing this account

vouchers_count: u64

number of vouchers issued (we can’t close account until everybody withdraws)

created_at: i64

the moment round was created

bidding_start: i64

bidding_end: i64

total_bid: Option<u64>

total bid balance when drop was accepted. Used for calculations

total_offer: Option<u64>

total offer balance when drop was accepted. Used for calculations

target_bid: u64

return_wallet: Pubkey

reserved1: [u8; 24]

reserved2: Pubkey

reserved3: Pubkey

Implementations

impl Round

pub fn assert_can_accept_or_reject(&self, now: UnixTimestamp) -> Result<()>

pub fn assert_can_contribute(&self, now: UnixTimestamp) -> Result<()>

pub fn assert_can_withdraw( &self, now: UnixTimestamp, user_is_signer: bool ) -> Result<()>

pub fn assert_can_redeem(&self) -> Result<()>

pub fn assert_can_cancel(&self, now: UnixTimestamp) -> Result<()>

pub fn assert_can_close(&self, now: UnixTimestamp) -> Result<()>

Trait Implementations

impl AccountDeserialize for Round

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for Round

fn try_serialize<W: Write>(&self, writer: &mut W) -> Result<()>

Serializes the account data into writer.

impl BorshDeserialize for Roundwhere RoundStatus: BorshDeserialize, Pubkey: BorshDeserialize, u64: BorshDeserialize, i64: BorshDeserialize, Option<u64>: BorshDeserialize, [u8; 24]: BorshDeserialize,

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.

impl BorshSerialize for Roundwhere RoundStatus: BorshSerialize, Pubkey: BorshSerialize, u64: BorshSerialize, i64: BorshSerialize, Option<u64>: BorshSerialize, [u8; 24]: BorshSerialize,

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

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Round

fn clone(&self) -> Round

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Round

fn default() -> Round

Returns the “default value” for a type.

impl Discriminator for Round

const DISCRIMINATOR: [u8; 8] = _

fn discriminator() -> [u8; 8]

impl Owner for Round

fn owner() -> Pubkey

impl Space for Round

const INIT_SPACE: usize = 339usize