Struct switchboard_solana::attestation_program::accounts::request::FunctionRequestAccountData

pub struct FunctionRequestAccountData {

    pub is_triggered: u8,
    pub status: RequestStatus,
    pub authority: Pubkey,
    pub payer: Pubkey,
    pub function: Pubkey,
    pub escrow: Pubkey,
    pub attestation_queue: Pubkey,
    pub active_request: FunctionRequestTriggerRound,
    pub previous_request: FunctionRequestTriggerRound,
    pub max_container_params_len: u32,
    pub container_params_hash: [u8; 32],
    pub container_params: Vec<u8>,
    pub created_at: i64,
    pub garbage_collection_slot: Option<u64>,
    pub error_status: u8,
    pub _ebuf: [u8; 255],
}

Fields

is_triggered: u8

Whether the request is ready to be processed.

status: RequestStatus

The status of the current request.

authority: Pubkey

Signer allowed to cancel the request.

payer: Pubkey

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

function: Pubkey

The function that can process this request

escrow: Pubkey

The tokenAccount escrow

attestation_queue: Pubkey

The Attestation Queue for this request.

active_request: FunctionRequestTriggerRound

The current active request.

previous_request: FunctionRequestTriggerRound

The previous request.

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.

created_at: i64

The unix timestamp when the function was created.

garbage_collection_slot: Option<u64>

The slot when the account can be garbage collected and closed by anyone for a portion of the rent.

error_status: u8

The last recorded error code if most recent response was an error.

_ebuf: [u8; 255]

Reserved.

Implementations

impl FunctionRequestAccountData

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

pub fn is_round_active(&self, clock: &Clock) -> bool

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

Validates that the provided request is assigned to the same AttestationQueueAccountData as the function and the provided enclave_signer matches the enclave_signer stored in the request’s active_request field.

Arguments

• request - The FunctionRequestAccountData being validated.
• enclave_signer - The AccountInfo of the enclave signer to validate.

Errors

Returns an error if:

• the function cannot be deserialized
• the function is not assigned to the request
• the function and request have different attestation queues
• the request’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::FunctionRequestAccountData;

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

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

impl FunctionRequestAccountData

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

Client Methods

pub async fn get_or_create_from_seed( rpc: &RpcClient, payer: Arc<Keypair>, function: Pubkey, seed: Option<&str>, params: Option<FunctionRequestInitAndTriggerParams> ) -> Result<Pubkey, SbError>

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_is_triggered_filter() -> RpcFilterType

pub fn get_is_active_filter() -> RpcFilterType

pub fn get_is_triggered_and_active_filter() -> RpcFilterType

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

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

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

pub fn get_is_ready_filters(queue_pubkey: &Pubkey) -> Vec<RpcFilterType>

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

Trait Implementations

impl AccountDeserialize for FunctionRequestAccountData

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 FunctionRequestAccountData

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

Serializes the account data into writer.

impl BorshDeserialize for FunctionRequestAccountData

where RequestStatus: BorshDeserialize, u64: BorshDeserialize, Pubkey: BorshDeserialize, FunctionRequestTriggerRound: 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 FunctionRequestAccountData

where RequestStatus: BorshSerialize, u64: BorshSerialize, Pubkey: BorshSerialize, FunctionRequestTriggerRound: BorshSerialize, Vec<u8>: 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 FunctionRequestAccountData

fn clone(&self) -> FunctionRequestAccountData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for FunctionRequestAccountData

fn default() -> Self

Returns the “default value” for a type.

impl Discriminator for FunctionRequestAccountData

const DISCRIMINATOR: [u8; 8] = _

fn discriminator() -> [u8; 8]

impl Owner for FunctionRequestAccountData

fn owner() -> Pubkey

impl PartialEq for FunctionRequestAccountData

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