Integrate Pyth Lazer as a Consumer on Solana

[dependencies]
pyth-lazer-solana-contract = { version = "x.y.z", features = ["no-entrypoint"] }

use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, FromPrimitive)]
pub enum Instruction {
    //...
    /// Update price.
    /// Data: `UpdateArgs` followed by a signed Pyth Lazer update.
    /// Accounts:
    /// 1. payer account
    /// 2. example data account [writable]
    /// 3. pyth program account [readonly]
    /// 4. pyth storage account [readonly]
    /// 5. pyth treasury account [writable]
    /// 6. system program [readonly]
    /// 7. instructions sysvar sysvar account [readonly]
    Update = 1,
}
 
/// Inputs to the `Update` instruction. `UpdateArgs` must be followed by a signed Pyth Lazer message.
#[derive(Debug, Clone, Copy, Zeroable, Pod)]
#[repr(C, packed)]
pub struct UpdateArgs {
    /// Example argument
    pub hello: u64,
}
 
/// Program entrypoint's implementation.
pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    // In our example contract, the first byte is the ID of the instruction.
    let instruction = *instruction_data
        .first()
        .ok_or(ProgramError::InvalidInstructionData)?;
    let instruction =
        Instruction::from_u8(instruction).ok_or(ProgramError::InvalidInstructionData)?;
    let instruction_args = &instruction_data[1..];
 
    match instruction {
        Instruction::Initialize => {
            process_initialize_instruction(program_id, accounts, instruction_args)
        }
        Instruction::Update => process_update_instruction(program_id, accounts, instruction_args),
    }
}
 
pub fn process_update_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_args: &[u8],
) -> ProgramResult {
    // Verify accounts passed to the instruction.
    if accounts.len() != 7 {
        return Err(ProgramError::NotEnoughAccountKeys);
    }
    let payer_account = &accounts[0];
    let data_account = &accounts[1];
    let _pyth_program_account = &accounts[2];
    let pyth_storage_account = &accounts[3];
    let pyth_treasury_account = &accounts[4];
    let system_program_account = &accounts[5];
    let instructions_sysvar_account = &accounts[6];
    // See below for next steps...
}

// We expect the instruction to the built-in ed25519 program to be
// the first instruction within the transaction.
let ed25519_instruction_index = 0;
// We expect our signature to be the first (and only) signature to be checked
// by the built-in ed25519 program within the transaction.
let signature_index = 0;
// Verify Lazer signature.
invoke(
    &ProgramInstruction::new_with_bytes(
        pyth_lazer_solana_contract::ID,
        &VerifyMessage {
            message_data: pyth_message.to_vec(),
            ed25519_instruction_index,
            signature_index,
        }
        .data(),
        vec![
            AccountMeta::new(*payer_account.key, true),
            AccountMeta::new_readonly(*pyth_storage_account.key, false),
            AccountMeta::new(*pyth_treasury_account.key, false),
            AccountMeta::new_readonly(*system_program_account.key, false),
            AccountMeta::new_readonly(*instructions_sysvar_account.key, false),
        ],
    ),
    &[
        payer_account.clone(),
        pyth_storage_account.clone(),
        pyth_treasury_account.clone(),
        system_program_account.clone(),
        instructions_sysvar_account.clone(),
    ],
)?;

// Deserialize and use the payload.
let data = PayloadData::deserialize_slice_le(verified.payload)
    .map_err(|_| ProgramError::InvalidInstructionData)?;
 
if data.feeds.is_empty() || data.feeds[0].properties.is_empty() {
    return Err(ProgramError::InvalidInstructionData);
}

// Read the data PDA of our example contract.
let mut state_data = data_account.data.borrow_mut();
let state =
    try_from_bytes_mut::<State>(*state_data).map_err(|_| ProgramError::InvalidAccountData)?;
 
if state.price_feed != data.feeds[0].feed_id.0 {
    return Err(ProgramError::InvalidInstructionData);
}
if data.channel_id != Channel::RealTime.id() {
    return Err(ProgramError::InvalidInstructionData);
}
if data.timestamp_us.0 <= state.latest_timestamp {
    return Err(ProgramError::AccountAlreadyInitialized);
}
let PayloadPropertyValue::Price(Some(price)) = data.feeds[0].properties[0] else {
    return Err(ProgramError::InvalidInstructionData);
};
state.latest_price = price.into_inner().into();
state.latest_timestamp = data.timestamp_us.0;