Enum clockwork_thread_program::state::Trigger

pub enum Trigger {
    Account {
        address: Pubkey,
        offset: u64,
        size: u64,
    },
    Cron {
        schedule: String,
        skippable: bool,
    },
    Now,
    Slot {
        slot: u64,
    },
    Epoch {
        epoch: u64,
    },
    Timestamp {
        unix_ts: i64,
    },
    Pyth {
        price_feed: Pubkey,
        equality: Equality,
        limit: i64,
    },
}

The triggering conditions of a thread.

Variants

Account

Fields

address: Pubkey

The address of the account to monitor.

offset: u64

The byte offset of the account data to monitor.

size: u64

The size of the byte slice to monitor (must be less than 1kb)

Allows a thread to be kicked off whenever the data of an account changes.

Cron

Fields

schedule: String

The schedule in cron syntax. Value must be parsable by the clockwork_cron package.

skippable: bool

Boolean value indicating whether triggering moments may be skipped if they are missed (e.g. due to network downtime). If false, any “missed” triggering moments will simply be executed as soon as the network comes back online.

Allows a thread to be kicked off according to a one-time or recurring schedule.

Now

Allows a thread to be kicked off as soon as it’s created.

Slot

Fields

slot: u64

Allows a thread to be kicked off according to a slot.

Epoch

Fields

epoch: u64

Allows a thread to be kicked off according to an epoch number.

Timestamp

Fields

unix_ts: i64

Allows a thread to be kicked off according to a unix timestamp.

Pyth

Fields

price_feed: Pubkey

The address of the price feed to monitor.

equality: Equality

The equality operator (gte or lte) used to compare prices.

limit: i64

The limit price to compare the Pyth feed to.

Allows a thread to be kicked off according to a Pyth price feed movement.

Trait Implementations

impl BorshDeserialize for Triggerwhere Pubkey: BorshDeserialize, u64: BorshDeserialize, String: BorshDeserialize, bool: BorshDeserialize, i64: BorshDeserialize, Equality: BorshDeserialize,

fn deserialize(buf: &mut &[u8]) -> Result<Trigger, 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 Triggerwhere Pubkey: BorshSerialize, u64: BorshSerialize, String: BorshSerialize, bool: BorshSerialize, i64: BorshSerialize, Equality: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl Clone for Trigger

fn clone(&self) -> Trigger

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Trigger

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

Formats the value using the given formatter.

impl PartialEq<Trigger> for Trigger

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Trigger