Struct switchboard_solana::attestation_program::accounts::routine::FunctionRoutineAccountData

pub struct FunctionRoutineAccountData {

    pub name: [u8; 64],
    pub metadata: [u8; 256],
    pub created_at: i64,
    pub updated_at: i64,
    pub is_disabled: ResourceLevel,
    pub status: RoutineStatus,
    pub error_status: u8,
    pub enclave_signer: Pubkey,
    pub verifier: Pubkey,
    pub bounty: u64,
    pub authority: Pubkey,
    pub payer: Pubkey,
    pub function: Pubkey,
    pub attestation_queue: Pubkey,
    pub escrow_wallet: Pubkey,
    pub escrow_token_wallet: Pubkey,
    pub queue_idx: u32,
    pub schedule: [u8; 64],
    pub max_container_params_len: u32,
    pub container_params_hash: [u8; 32],
    pub container_params: Vec<u8>,
    pub last_execution_timestamp: i64,
    pub last_successful_execution_timestamp: i64,
    pub next_allowed_timestamp: i64,
    pub _ebuf: [u8; 512],
}

Fields

name: [u8; 64]

The name of the function routine for easier identification.

metadata: [u8; 256]

The metadata of the function routine for easier identification.

created_at: i64

The unix timestamp when the function routine was created.

updated_at: i64

The unix timestamp when the function routine config was changed.

is_disabled: ResourceLevel

Flag to disable the function and prevent new verification requests.

status: RoutineStatus

The type of resource that disabled the routine.

error_status: u8

The last reported error code if the most recent response was a failure

enclave_signer: Pubkey

The enclave generated signer for this routine.

verifier: Pubkey

The verifier oracle who signed this verification.

bounty: u64

The SOL bounty in lamports used to incentivize a verifier to expedite the request. 0 = no bounty. Receiver = verifier oracle.

authority: Pubkey

Signer allowed to manage the routine.

payer: Pubkey

The default destination for rent exemption when the account is closed.

function: Pubkey

The function that manages the mr_enclave set for this routine.

attestation_queue: Pubkey

The Attestation Queue for this request.

escrow_wallet: Pubkey

The tokenAccount escrow

escrow_token_wallet: Pubkey

The TokenAccount with funds for the escrow.

queue_idx: u32

The index of the verifier on the queue that is assigned to process the next invocation. This is incremented after each invocation in a round-robin fashion.

schedule: [u8; 64]

The cron schedule to run the function on.

max_container_params_len: u32

The maximum number of bytes to pass to the container params.

container_params_hash: [u8; 32]

Hash of the serialized container_params to prevent RPC tampering. Should be verified within your function to ensure you are using the correct parameters.

container_params: Vec<u8>

The stringified container params to pass to the function.

last_execution_timestamp: i64

The unix timestamp when the function was last run.

last_successful_execution_timestamp: i64

The unix timestamp when the function was last run successfully.

next_allowed_timestamp: i64

The unix timestamp when the function is allowed to run next.

_ebuf: [u8; 512]

Reserved.

Implementations

impl FunctionRoutineAccountData

pub fn space(len: Option<u32>) -> usize

Returns the amount of memory space required for a FunctionRoutine account.

Arguments

• len - An optional u32 value representing the length of the container parameters vector.

Returns

• usize - The total amount of memory space required for a FunctionRoutine account.

pub fn assert_data_len(account_info: &AccountInfo<'_>, len: Option<u32>) -> bool

Asserts that the length of the account data matches the expected length.

Arguments

• account_info - The account info to check the data length of.
• len - The expected length of the account data.

Errors

Returns an error if the length of the account data does not match the expected length.

pub fn is_empty_schedule(&self) -> bool

Checks if the schedule is empty by reading the first byte.

Returns

A boolean indicating whether the schedule is empty or not.

pub fn is_disabled(&self) -> bool

Returns a bool representing whether the routine is disabled for use.

pub fn validate_signer<'a>( &self, function_loader: &AccountLoader<'a, FunctionAccountData>, enclave_signer: &AccountInfo<'a> ) -> Result<bool>

Validates the given signer account against the function_loader and the enclave_signer stored in this FunctionRoutineAccountData.

Arguments

• function_loader - The AccountLoader of the function account to validate.
• enclave_signer - The AccountInfo of the enclave signer to validate.

Errors

Returns an error if:

• the function cannot be deserialized
• the routine is not assigned to the function
• the function and routine have different attestation queues
• the routine’s verified signer does not match the provided enclave_signer
• the enclave_signer did not sign the transaction

Returns

Returns Ok(true) if the validation succeeds, Ok(false) otherwise.

Examples

use switchboard_solana::FunctionRoutineAccountData;

#[derive(Accounts)]
pub struct Settle<'info> {
    // YOUR PROGRAM ACCOUNTS
    #[account(
        mut,
        has_one = switchboard_routine,
    )]
    pub user: AccountLoader<'info, UserState>,

    // SWITCHBOARD ACCOUNTS
    pub switchboard_function: AccountLoader<'info, FunctionAccountData>,
    #[account(
        constraint = switchboard_routine.validate_signer(
            &switchboard_function,
            &enclave_signer.to_account_info()
        )?
    )]
    pub switchboard_routine: Box<Account<'info, FunctionRoutineAccountData>>,
    pub enclave_signer: Signer<'info>,
}

pub fn get_name(&self) -> String

pub fn get_metadata(&self) -> String

impl FunctionRoutineAccountData

pub async fn get_program_accounts( rpc: &RpcClient, filters: FunctionRoutineFilters, commitment: Option<CommitmentLevel> ) -> Result<Vec<(Pubkey, FunctionRoutineAccountData)>, SbError>

Client Methods

pub fn fetch(client: &RpcClient, pubkey: Pubkey) -> Result<Self, SbError>

Fetch Methods

pub async fn fetch_async( client: &RpcClient, pubkey: Pubkey ) -> Result<Self, SbError>

pub fn fetch_sync<T: SyncClient>( client: &T, pubkey: Pubkey ) -> Result<Self, SbError>

pub fn get_discriminator_filter() -> RpcFilterType

pub fn get_authority_filter(authority_pubkey: &Pubkey) -> RpcFilterType

pub fn get_queue_filter(queue_pubkey: &Pubkey) -> RpcFilterType

pub fn get_queue_idx_filter(queue_idx: &u32) -> RpcFilterType

pub fn get_is_enabled_filter() -> RpcFilterType

pub fn get_metadata_filter(metadata: Vec<u8>) -> RpcFilterType

pub fn get_schedule(&self) -> Option<Schedule>

pub fn get_last_execution_datetime(&self) -> DateTime<Utc>

pub fn get_next_execution_datetime(&self) -> Option<DateTime<Utc>>

pub fn should_execute(&self, now: DateTime<Utc>) -> bool

pub fn calc_container_params_hash(container_params: &Vec<u8>) -> [u8; 32]

pub fn get_container_params_hash(&self) -> [u8; 32]

Trait Implementations

impl AccountDeserialize for FunctionRoutineAccountData

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 FunctionRoutineAccountData

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

Serializes the account data into writer.

impl BorshDeserialize for FunctionRoutineAccountData

where [u8; 64]: BorshDeserialize, [u8; 256]: BorshDeserialize, i64: BorshDeserialize, ResourceLevel: BorshDeserialize, RoutineStatus: BorshDeserialize, u8: BorshDeserialize, Pubkey: BorshDeserialize, u64: BorshDeserialize, u32: BorshDeserialize, [u8; 32]: BorshDeserialize, Vec<u8>: BorshDeserialize, [u8; 512]: 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 FunctionRoutineAccountData

where [u8; 64]: BorshSerialize, [u8; 256]: BorshSerialize, i64: BorshSerialize, ResourceLevel: BorshSerialize, RoutineStatus: BorshSerialize, u8: BorshSerialize, Pubkey: BorshSerialize, u64: BorshSerialize, u32: BorshSerialize, [u8; 32]: BorshSerialize, Vec<u8>: BorshSerialize, [u8; 512]: 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 FunctionRoutineAccountData

fn clone(&self) -> FunctionRoutineAccountData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for FunctionRoutineAccountData

fn default() -> Self

Returns the “default value” for a type.

impl Discriminator for FunctionRoutineAccountData

const DISCRIMINATOR: [u8; 8] = _

fn discriminator() -> [u8; 8]

impl Owner for FunctionRoutineAccountData

fn owner() -> Pubkey

impl PartialEq for FunctionRoutineAccountData

fn eq(&self, other: &FunctionRoutineAccountData) -> 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 FunctionRoutineAccountData