Struct Contract 

#[repr(C)]
pub struct Contract {

    pub magic: u64,
    pub version: u8,
    pub created_at: u64,
    pub amount_withdrawn: u64,
    pub canceled_at: u64,
    pub end_time: u64,
    pub last_withdrawn_at: u64,
    pub sender: Pubkey,
    pub sender_tokens: Pubkey,
    pub recipient: Pubkey,
    pub recipient_tokens: Pubkey,
    pub mint: Pubkey,
    pub escrow_tokens: Pubkey,
    pub streamflow_treasury: Pubkey,
    pub streamflow_treasury_tokens: Pubkey,
    pub streamflow_fee_total: u64,
    pub streamflow_fee_withdrawn: u64,
    pub streamflow_fee_percent: f32,
    pub partner: Pubkey,
    pub partner_tokens: Pubkey,
    pub partner_fee_total: u64,
    pub partner_fee_withdrawn: u64,
    pub partner_fee_percent: f32,
    pub ix: CreateParams,
    pub ix_padding: Vec<u8>,
    pub closed: bool,
    pub current_pause_start: u64,
    pub pause_cumulative: u64,
    pub last_rate_change_time: u64,
    pub funds_unlocked_at_last_rate_change: u64,
}

Struct that represents Stream Contract stored on chain, this account DOES NOT have a discriminator.

May be read like so

let stream_metadata: Contract = match try_from_slice_unchecked(&stream_data) {
    Ok(v) => v,
    Err(_) => return err!(ErrorCode::InvalidStreamMetadata),
};

Fields

magic: u64

Magic bytes

version: u8

Version of the program

created_at: u64

Timestamp when stream was created

amount_withdrawn: u64

Amount of funds withdrawn

canceled_at: u64

Timestamp when stream was canceled (if canceled)

end_time: u64

Timestamp at which stream can be safely canceled by a 3rd party (Stream is either fully vested or there isn’t enough capital to keep it active)

last_withdrawn_at: u64

Timestamp of the last withdrawal

sender: Pubkey

Pubkey of the stream initializer

sender_tokens: Pubkey

Pubkey of the stream initializer’s token account

recipient: Pubkey

Pubkey of the stream recipient

recipient_tokens: Pubkey

Pubkey of the stream recipient’s token account

mint: Pubkey

Pubkey of the token mint

escrow_tokens: Pubkey

Escrow account holding the locked tokens for recipient

streamflow_treasury: Pubkey

Streamflow treasury authority

streamflow_treasury_tokens: Pubkey

Escrow account holding the locked tokens for Streamflow (fee account)

streamflow_fee_total: u64

The total fee amount for streamflow

streamflow_fee_withdrawn: u64

The withdrawn fee amount for streamflow

streamflow_fee_percent: f32

Fee percentage for Streamflow

partner: Pubkey

Streamflow partner authority

partner_tokens: Pubkey

Escrow account holding the locked tokens for Streamflow partner (fee account)

partner_fee_total: u64

The total fee amount for the partner

partner_fee_withdrawn: u64

The withdrawn fee amount for the partner

partner_fee_percent: f32

Fee percentage for partner

ix: CreateParams

The stream instruction

ix_padding: Vec<u8>

Padding for ix: CreateParams to allow for future upgrades.

closed: bool

Stream is closed

current_pause_start: u64

time of the current pause. 0 signifies unpaused state

pause_cumulative: u64

total time the contract was paused for

last_rate_change_time: u64

timestamp of last rate change for this stream. Rate can be changed with update instruction

funds_unlocked_at_last_rate_change: u64

Accumulated unlocked tokens before last rate change (excluding cliff_amount)

Implementations

impl Contract

pub fn start_time(&self) -> u64

pub fn effective_start_time(&self) -> u64

pub fn pause_time(&self, now: u64) -> u64

pub fn vested_available(&self, now: u64) -> u64

amount available that is vested (excluding cliff)

pub fn available_to_claim(&self, now: u64, fee_percentage: f32) -> u64

pub fn cliff_available(&self, now: u64) -> u64

Trait Implementations

impl BorshDeserialize for Contract

where u64: BorshDeserialize, u8: BorshDeserialize, Pubkey: BorshDeserialize, f32: BorshDeserialize, CreateParams: BorshDeserialize, Vec<u8>: BorshDeserialize, bool: BorshDeserialize,

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 Contract

where u64: BorshSerialize, u8: BorshSerialize, Pubkey: BorshSerialize, f32: BorshSerialize, CreateParams: BorshSerialize, Vec<u8>: BorshSerialize, bool: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl Clone for Contract

fn clone(&self) -> Contract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Contract

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

Formats the value using the given formatter.