Struct switchboard_solana::attestation_program::accounts::service::FunctionServiceAccountData

pub struct FunctionServiceAccountData {

    pub attestation_queue: Pubkey,
    pub service_worker: Pubkey,
    pub status: ServiceStatus,
    pub is_disabled: ResourceLevel,
    pub enclave_rotation_status: EnclaveRotationStatus,
    pub error_status: u8,
    pub authority: Pubkey,
    pub function: Pubkey,
    pub escrow_wallet: Pubkey,
    pub escrow_token_wallet: Pubkey,
    pub name: [u8; 64],
    pub metadata: [u8; 256],
    pub created_at: i64,
    pub updated_at: i64,
    pub enclave: BorshQuote,
    pub previous_enclave: BorshQuote,
    pub pending_enclave: BorshQuote,
    pub last_rotation_timestamp: i64,
    pub queue_idx: u32,
    pub max_container_params_len: u32,
    pub container_params_hash: [u8; 32],
    pub container_params: Vec<u8>,
    pub enclave_size: u64,
    pub cpu: u64,
    pub _ebuf: [u8; 512],
}

A FunctionServiceAccountData represents a long running function for a given FunctionAccountData. A service determines the execution parameters (environment variables, oracle config, cost).

Fields

attestation_queue: Pubkey

The Attestation Queue for this service, responsible for verifying any SGX quotes.

service_worker: Pubkey

The service workerr that is executing the managed service.

status: ServiceStatus

The status of the current service. 0 = disabled, 1 = active.

is_disabled: ResourceLevel

Flag to disable the service and prevent new verification requests.

enclave_rotation_status: EnclaveRotationStatus

Whether the enclave is in progress for being rotated. Used for quote verifiers to filter and find pending verification requests.

error_status: u8

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

authority: Pubkey

Signer allowed to manage the service.

function: Pubkey

The pubkey of the FunctionAccountData that this service belongs to.

escrow_wallet: Pubkey

escrow_token_wallet: Pubkey

The TokenAccount with funds for the escrow.

name: [u8; 64]

The name of the service for easier identification.

metadata: [u8; 256]

The metadata of the service for easier identification.

created_at: i64

The unix timestamp when the service was created.

updated_at: i64

The unix timestamp when the service was last updated.

enclave: BorshQuote

Represents the state of the quote verifiers enclave.

previous_enclave: BorshQuote

The previous verified quote. Used to facilitate smooth transitions during signer rotations.

pending_enclave: BorshQuote

The pending Quote indicating a signer rotation is in-progress.

last_rotation_timestamp: i64

The timestamp when the signer was last rotated.

queue_idx: u32

The index on the queue of the verifier that is assigned to verify the SGX quote.

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.

enclave_size: u64

The size of the enclave to reserve, in bytes.

cpu: u64

_ebuf: [u8; 512]

Reserved.

Implementations

impl FunctionServiceAccountData

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

Returns the amount of memory space required for a FunctionService 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 FunctionService account.

pub fn ready_for_quote_rotation( &self, func_signer_rotation_interval: i64 ) -> bool

Checks if the enclave is ready to rotate its quote.

Returns

• bool - true if the routine is ready for quote rotation, false otherwise.

pub fn set_name(&mut self, name: &Option<Vec<u8>>) -> Result<()>

Sets the name of the routine.

Arguments

• name - An optional vector of bytes representing the name of the routine.

Errors

Returns an error if the length of the name is greater than 64 bytes.

Example

let mut routine = FunctionServiceAccountData::default();
let name = Some(vec![72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
routine.set_name(&name).unwrap();

pub fn set_metadata(&mut self, metadata: &Option<Vec<u8>>) -> Result<()>

If provided, set the metadata for the function routine for easier identification.

Errors

Returns an error if the length of the metadata is greater than 256 bytes.

pub fn is_disabled(&self) -> bool

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

pub fn set_container_params( &mut self, container_params: &mut Vec<u8>, append_container_params: bool ) -> Result<()>

Sets the container parameters for the routine. Optionally pass a param to append the bytes to the existing container parameters.

Arguments

• container_params - A mutable reference to a vector of bytes representing the container parameters.
• append_container_params - A boolean indicating whether to append the container parameters to the existing ones or replace them.

Errors

Returns an error if the length of the container parameters exceeds the maximum allowed length.

Returns

Returns Ok(()) if the operation was successful.

pub fn save_enclave( &mut self, clock: &Clock, error_code: u8, verifier: &Pubkey, mr_enclave: &[u8; 32], func_signer_rotation_interval: i64, queue_data_len: u32 ) -> Result<()>

Saves the enclave verification

Arguments

• clock - The current clock instance.
• error_code - The error code for the attestation round.
• verifier - The public key of the verifier.
• enclave_signer - The public key of the enclave signer.
• queue_data_len - The number of oracles heartbeating on the attestation queue.

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

Validates the given signer account against the function_account_info and the enclave_signer stored in this FunctionServiceAccountData.

Arguments

• function_account_info - The AccountInfo of the function account.
• signer - The AccountInfo of the account to validate.

Errors

Returns an error if the function account data cannot be loaded or if the signer account does not match the expected enclave_signer.

Returns

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

Examples

use switchboard_solana::FunctionServiceAccountData;

#[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_service.validate_signer(
            &switchboard_function.to_account_info(),
            &enclave_signer.to_account_info()
        )?
    )]
    pub switchboard_service: Box<Account<'info, FunctionServiceAccountData>>,
    pub enclave_signer: Signer<'info>,
}

pub fn get_name(&self) -> String

pub fn get_metadata(&self) -> String

impl FunctionServiceAccountData

pub async fn get_program_accounts( rpc: &RpcClient, filters: FunctionServiceFilters ) -> Result<Vec<(Pubkey, FunctionServiceAccountData)>, 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_worker_filter(queue_pubkey: &Pubkey) -> RpcFilterType

pub fn get_queue_and_worker_filter( queue_pubkey: &Pubkey, worker_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

Trait Implementations

impl AccountDeserialize for FunctionServiceAccountData

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 FunctionServiceAccountData

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

Serializes the account data into writer.

impl BorshDeserialize for FunctionServiceAccountData

where Pubkey: BorshDeserialize, ServiceStatus: BorshDeserialize, ResourceLevel: BorshDeserialize, EnclaveRotationStatus: BorshDeserialize, u8: BorshDeserialize, [u8; 64]: BorshDeserialize, [u8; 256]: BorshDeserialize, i64: BorshDeserialize, BorshQuote: BorshDeserialize, u32: BorshDeserialize, [u8; 32]: BorshDeserialize, Vec<u8>: BorshDeserialize, u64: 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 FunctionServiceAccountData

where Pubkey: BorshSerialize, ServiceStatus: BorshSerialize, ResourceLevel: BorshSerialize, EnclaveRotationStatus: BorshSerialize, u8: BorshSerialize, [u8; 64]: BorshSerialize, [u8; 256]: BorshSerialize, i64: BorshSerialize, BorshQuote: BorshSerialize, u32: BorshSerialize, [u8; 32]: BorshSerialize, Vec<u8>: BorshSerialize, u64: 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 FunctionServiceAccountData

fn clone(&self) -> FunctionServiceAccountData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionServiceAccountData

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

Formats the value using the given formatter.

impl Default for FunctionServiceAccountData

fn default() -> Self

Returns the “default value” for a type.

impl Discriminator for FunctionServiceAccountData

const DISCRIMINATOR: [u8; 8] = _

fn discriminator() -> [u8; 8]

impl Owner for FunctionServiceAccountData

fn owner() -> Pubkey

impl PartialEq for FunctionServiceAccountData

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