Struct human_royalty::state::State

pub struct State {

    pub wallet: Pubkey,
    pub owner: Pubkey,
    pub host: Pubkey,
    pub total_distributed: u64,
    pub total_user_distributed: u64,
    pub settings: Settings,
    pub drop_idx: u32,
    pub vouchers_count: u32,
    pub tokens_held: u64,
    pub distribution: Option<Distribution>,
    pub token_mint: Pubkey,
    pub realm_addr: Pubkey,
    pub vault_addr: Pubkey,
}

Fields

wallet: Pubkey

owner: Pubkey

host: Pubkey

total_distributed: u64

total amount distributed on the contract

total_user_distributed: u64

total amount distributed minus host and owner split

settings: Settings

drop_idx: u32

drop_idx is monotonically growing counter to track redeemed voucher voucher could only redeemed if it’s drop_idx matches state’s one on redeem it’s drop_idx is incremented, so it can only be redeemed in next drop. Vouchers are created with current drop_idx, but since they can’t be issued in the middle of distribution, we are safe

vouchers_count: u32

total vouchers in circulation

tokens_held: u64

total token balance in stake. counted separately to prevent someone from sending tokens directly to wallet and breaking math in the middle of distribution these tokens will also reduce everyone’s share

distribution: Option<Distribution>

current distribution

token_mint: Pubkey

Staking token mint

realm_addr: Pubkey

While forming voting record, use this field

vault_addr: Pubkey

Vault addr to add weight to creator vote

Trait Implementations

impl BorshDeserialize for Statewhere Pubkey: BorshDeserialize, u64: BorshDeserialize, Settings: BorshDeserialize, u32: BorshDeserialize, Option<Distribution>: 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 Statewhere Pubkey: BorshSerialize, u64: BorshSerialize, Settings: BorshSerialize, u32: BorshSerialize, Option<Distribution>: 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 Debug for State

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

Formats the value using the given formatter.

impl Entity for State

const SIZE: usize = 512usize

const MAGIC: u8 = 119u8

const DATA_SIZE: usize = Self::SIZE - 1

fn serialize_to(&self, data: &mut [u8]) -> Result<(), ProgramError>

fn deserialize_from(data: &[u8]) -> Result<Self, ProgramError>

fn is_initialized(data: &[u8]) -> bool