switchboard-on-demand 0.12.1

use crate::on_demand::oracle_quote::feed_info::{PackedFeedInfo, PackedQuoteHeader};
#[cfg(feature = "anchor")]
use crate::on_demand::oracle_quote::instruction_parser::ParsedQuotePayload;
use crate::on_demand::oracle_quote::authority_quote::QuoteSourceScheme;
use crate::smallvec::{SmallVec, U16Prefix, U8Prefix};
use crate::sysvar::ed25519_sysvar::Ed25519SignatureOffsets;
use crate::Pubkey;

pub const QUOTE_DISCRIMINATOR: &[u8; 8] = b"SBOracle";

/// Oracle signature data with offsets
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(C)]
pub struct OracleSignature {
    /// Offsets to locate signature data within instruction
    pub offsets: Ed25519SignatureOffsets,
    /// ED25519 public key
    pub pubkey: Pubkey,
    /// ED25519 signature (64 bytes)
    pub signature: [u8; 64],
}

impl borsh::BorshSerialize for OracleSignature {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        self.offsets.serialize(writer)?;
        writer.write_all(self.pubkey.as_ref())?;
        writer.write_all(&self.signature)?;
        Ok(())
    }
}

impl borsh::BorshDeserialize for OracleSignature {
    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        let offsets = Ed25519SignatureOffsets::deserialize_reader(reader)?;
        let mut pubkey_bytes = [0u8; 32];
        reader.read_exact(&mut pubkey_bytes)?;
        let pubkey = Pubkey::new_from_array(pubkey_bytes);
        let mut signature = [0u8; 64];
        reader.read_exact(&mut signature)?;
        Ok(Self {
            offsets,
            pubkey,
            signature,
        })
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::AnchorDeserialize for OracleSignature {
    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        <Self as borsh::BorshDeserialize>::deserialize_reader(reader)
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::AnchorSerialize for OracleSignature {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        <Self as borsh::BorshSerialize>::serialize(self, writer)
    }
}

#[cfg(feature = "idl-build")]
impl anchor_lang::IdlBuild for OracleSignature {}

/// Switchboard oracle quote account structure
///
/// # On-chain Layout (excluding 8-byte discriminator):
/// ```text
/// [0..32]      namespace: Queue pubkey for oracle quotes, authority pubkey for authority quotes (32 bytes)
/// [34..]       signatures: SmallVec of OracleSignature (2-byte u16 length + 110 bytes each)
///              - Ed25519SignatureOffsets (14 bytes)
///              - pubkey (32 bytes)
///              - signature (64 bytes)
/// [..]         quote_header: PackedQuoteHeader (32 bytes)
/// [..]         feeds: SmallVec of PackedFeedInfo (1-byte u8 length + 49 bytes each)
/// [..]         oracle_idxs: SmallVec of oracle indices (1-byte u8 length + u8 each)
/// [..]         slot: Slot number (u64, 8 bytes)
/// [..]         version: Version (u8, 1 byte)
/// [..]         tail_discriminator: "SBOD" (4 bytes)
/// ```
///
/// # Length Prefix Sizes
/// - `signatures`: 2-byte (u16) length prefix - allows up to 65535 signatures
/// - `feeds`: 1-byte (u8) length prefix - max 255 feeds
/// - `oracle_idxs`: 1-byte (u8) length prefix - max 255 indices
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SwitchboardQuote {
    /// Namespace pubkey stored with this quote.
    ///
    /// Oracle quotes store the queue pubkey here. Authority quotes store the
    /// authority pubkey that owns the quote stream here.
    pub queue: Pubkey,
    /// Uses 2-byte (u16) length prefix
    pub signatures: SmallVec<OracleSignature, U16Prefix>,
    /// Quote header containing the signed slot hash
    pub quote_header: PackedQuoteHeader,
    /// Array of feed information (max 255)
    /// Uses 1-byte (u8) length prefix
    pub feeds: SmallVec<PackedFeedInfo, U8Prefix>,
    /// Oracle indices that correspond to the queue's oracle array (max 255)
    /// Uses 1-byte (u8) length prefix
    pub oracle_idxs: SmallVec<u8, U8Prefix>,
    /// Recent slot from the ED25519 instruction data used for freshness validation
    pub slot: u64,
    /// Version from the ED25519 instruction data
    pub version: u8,
    /// Tail discriminator "SBOD" for validation
    pub tail_discriminator: [u8; 4],
}

impl borsh::BorshSerialize for SwitchboardQuote {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        writer.write_all(self.queue.as_ref())?;
        self.signatures.serialize(writer)?;
        self.quote_header.serialize(writer)?;
        self.feeds.serialize(writer)?;
        self.oracle_idxs.serialize(writer)?;
        self.slot.serialize(writer)?;
        self.version.serialize(writer)?;
        self.tail_discriminator.serialize(writer)?;
        Ok(())
    }
}

impl borsh::BorshDeserialize for SwitchboardQuote {
    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        let mut queue_bytes = [0u8; 32];
        reader.read_exact(&mut queue_bytes)?;
        Ok(Self {
            queue: Pubkey::new_from_array(queue_bytes),
            signatures: borsh::BorshDeserialize::deserialize_reader(reader)?,
            quote_header: borsh::BorshDeserialize::deserialize_reader(reader)?,
            feeds: borsh::BorshDeserialize::deserialize_reader(reader)?,
            oracle_idxs: borsh::BorshDeserialize::deserialize_reader(reader)?,
            slot: borsh::BorshDeserialize::deserialize_reader(reader)?,
            version: borsh::BorshDeserialize::deserialize_reader(reader)?,
            tail_discriminator: borsh::BorshDeserialize::deserialize_reader(reader)?,
        })
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::AnchorDeserialize for SwitchboardQuote {
    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        <Self as borsh::BorshDeserialize>::deserialize_reader(reader)
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::AnchorSerialize for SwitchboardQuote {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        <Self as borsh::BorshSerialize>::serialize(self, writer)
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::Discriminator for SwitchboardQuote {
    const DISCRIMINATOR: &'static [u8] = QUOTE_DISCRIMINATOR;
}

#[cfg(feature = "anchor")]
impl anchor_lang::AccountSerialize for SwitchboardQuote {
    fn try_serialize<W: std::io::Write>(&self, writer: &mut W) -> anchor_lang::Result<()> {
        use anchor_lang::Discriminator;

        // Write discriminator (8 bytes)
        writer.write_all(Self::DISCRIMINATOR)?;

        // Write queue pubkey (32 bytes)
        writer.write_all(self.queue.as_ref())?;

        // Serialize the delimited data to a buffer first to get length
        let mut delimited_buf = Vec::new();
        borsh::BorshSerialize::serialize(&self.signatures, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.quote_header, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.feeds, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.oracle_idxs, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.slot, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.version, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
        borsh::BorshSerialize::serialize(&self.tail_discriminator, &mut delimited_buf)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;

        // Write u16 length prefix
        let len = delimited_buf.len() as u16;
        writer.write_all(&len.to_le_bytes())?;

        // Write delimited data
        writer.write_all(&delimited_buf)?;

        Ok(())
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::AccountDeserialize for SwitchboardQuote {
    fn try_deserialize(buf: &mut &[u8]) -> anchor_lang::Result<Self> {
        use anchor_lang::Discriminator;

        // Check minimum size: discriminator (8) + queue (32) = 40 bytes minimum
        if buf.len() < 40 {
            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorNotFound.into());
        }

        // Check discriminator
        let given_disc = &buf[..Self::DISCRIMINATOR.len()];
        if given_disc != Self::DISCRIMINATOR {
            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorMismatch.into());
        }

        // Extract namespace pubkey (bytes 8-40)
        let namespace = Pubkey::new_from_array(buf[8..40].try_into().unwrap());

        // Parse length-delimited ED25519 instruction data starting at byte 40
        let data = &buf[40..];
        if data.len() < 2 {
            return Err(anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into());
        }

        // Read u16 length prefix
        let len = u16::from_le_bytes([data[0], data[1]]) as usize;
        if data.len() < len + 2 {
            return Err(anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into());
        }

        // Parse the ED25519 instruction data
        let ed25519_data = &data[2..len + 2];
        parse_switchboard_quote(namespace, ed25519_data)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into())
    }

    fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_lang::Result<Self> {
        if buf.len() < 40 {
            return Err(anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into());
        }

        let full_buf = *buf;
        *buf = &[]; // Consume the buffer

        // Extract namespace pubkey (bytes 8-40) - skip discriminator check for unchecked
        let namespace = Pubkey::new_from_array(full_buf[8..40].try_into().unwrap());

        // Parse length-delimited ED25519 instruction data starting at byte 40
        let data = &full_buf[40..];
        if data.len() < 2 {
            return Err(anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into());
        }

        // Read u16 length prefix
        let len = u16::from_le_bytes([data[0], data[1]]) as usize;
        if data.len() < len + 2 {
            return Err(anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into());
        }

        // Parse the ED25519 instruction data
        let ed25519_data = &data[2..len + 2];
        parse_switchboard_quote(namespace, ed25519_data)
            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into())
    }
}

#[cfg(feature = "idl-build")]
impl anchor_lang::IdlBuild for SwitchboardQuote {}

impl SwitchboardQuote {
    /// Maximum serialized size estimate for account initialization
    /// This is conservative: queue(32) + max_sigs(2 + 8*110) + quote_header(32) + max_feeds(1 + 8*49) + oracle_idxs(1 + 8) + slot(8) + version(1) + tail(4)
    pub const MAX_LEN: usize = 32 + (2 + 8 * 110) + 32 + (1 + 8 * 49) + (1 + 8) + 8 + 1 + 4;

    /// Minimum size for empty quote
    pub const MIN_LEN: usize = 32 + 2 + 32 + 1 + 1 + 8 + 1 + 4;

    /// Returns a reference to the feed information array
    ///
    /// # Example
    /// ```rust
    /// let feeds = quote.feeds_slice();
    /// for feed in feeds {
    ///     println!("Feed {}: {}", feed.hex_id(), feed.value());
    /// }
    /// ```
    pub fn feeds_slice(&self) -> &[PackedFeedInfo] {
        self.feeds.as_slice()
    }

    pub fn source_scheme(&self) -> QuoteSourceScheme {
        let signed_slothash = self.quote_header.signed_slothash;
        if self.signatures.is_empty() && self.oracle_idxs.is_empty() && signed_slothash == [0u8; 32]
        {
            QuoteSourceScheme::Authority
        } else {
            QuoteSourceScheme::Oracle
        }
    }

    /// Get the canonical oracle account public key for the given feed IDs
    ///
    /// This method derives the canonical oracle account that the quote program
    /// creates and manages for storing verified oracle data.
    ///
    /// ## Parameters
    /// - `queue_key`: The queue public key to use as the first seed
    /// - `feed_ids`: Array of feed ID byte arrays (32 bytes each)
    /// - `program_id`: The quote program ID to use for derivation
    ///
    /// ## Returns
    /// The canonical oracle account public key
    ///
    /// ## Example
    /// ```rust,ignore
    /// let oracle_key = SwitchboardQuote::get_canonical_key(&queue_key, &[feed_id_bytes], &quote_program_id);
    /// ```
    #[cfg(feature = "anchor")]
    pub fn get_canonical_key(
        queue_key: &anchor_lang::solana_program::pubkey::Pubkey,
        feed_ids: &[&[u8; 32]],
        program_id: &anchor_lang::solana_program::pubkey::Pubkey,
    ) -> anchor_lang::solana_program::pubkey::Pubkey {
        let mut seeds: Vec<&[u8]> = Vec::with_capacity(feed_ids.len() + 1);
        seeds.push(queue_key.as_ref());
        for id in feed_ids {
            seeds.push(id.as_slice());
        }
        let (oracle_account, _) =
            anchor_lang::solana_program::pubkey::Pubkey::find_program_address(&seeds, program_id);
        oracle_account
    }

    /// Get the canonical oracle account for this quote's feeds
    ///
    /// Convenience method that extracts feed IDs from the current quote
    /// and derives the canonical oracle account using the provided owner.
    ///
    /// ## Parameters
    /// - `queue_key`: The queue public key to use as the first seed
    /// - `owner`: The program ID that owns this oracle account (usually the quote program)
    ///
    /// ## Returns
    /// The canonical oracle account public key for this quote's feeds
    ///
    /// ## Example
    /// ```rust,ignore
    /// let canonical_key = quote.canonical_key(&queue_key, &oracle_account.owner);
    /// ```
    #[cfg(feature = "anchor")]
    pub fn canonical_key(
        &self,
        queue_key: &anchor_lang::solana_program::pubkey::Pubkey,
        owner: &anchor_lang::solana_program::pubkey::Pubkey,
    ) -> anchor_lang::solana_program::pubkey::Pubkey {
        let feed_ids: Vec<&[u8; 32]> = self.feeds.iter().map(|feed| &feed.feed_id).collect();
        Self::get_canonical_key(queue_key, &feed_ids, owner)
    }
}

#[cfg(feature = "anchor")]
impl anchor_lang::Owner for SwitchboardQuote {
    fn owner() -> anchor_lang::solana_program::pubkey::Pubkey {
        crate::QUOTE_PROGRAM_ID
    }
}

#[cfg(feature = "anchor")]
fn parse_switchboard_quote(
    namespace: Pubkey,
    quote_data: &[u8],
) -> anyhow::Result<SwitchboardQuote> {
    match ParsedQuotePayload::parse(quote_data)? {
        ParsedQuotePayload::Oracle(parsed) => {
            let signatures = parsed
                .signatures
                .into_iter()
                .map(|sig| OracleSignature {
                    offsets: sig.offsets,
                    pubkey: Pubkey::new_from_array(sig.pubkey),
                    signature: sig.signature,
                })
                .collect::<Vec<_>>()
                .try_into()
                .map_err(|_| anyhow::anyhow!("Too many quote signatures"))?;
            let feeds = parsed
                .feeds
                .into_iter()
                .collect::<Vec<_>>()
                .try_into()
                .map_err(|_| anyhow::anyhow!("Too many quote feeds"))?;
            let oracle_idxs = parsed
                .oracle_idxs
                .into_iter()
                .collect::<Vec<_>>()
                .try_into()
                .map_err(|_| anyhow::anyhow!("Too many oracle indexes"))?;

            Ok(SwitchboardQuote {
                queue: namespace,
                signatures,
                quote_header: parsed.quote_header,
                feeds,
                oracle_idxs,
                slot: parsed.slot,
                version: parsed.version,
                tail_discriminator: parsed.discriminator,
            })
        }
        ParsedQuotePayload::Authority(parsed) => {
            let quote_header = parsed.quote_header();
            let feeds = parsed
                .feeds
                .into_iter()
                .collect::<Vec<_>>()
                .try_into()
                .map_err(|_| anyhow::anyhow!("Too many authority quote feeds"))?;

            Ok(SwitchboardQuote {
                queue: namespace,
                signatures: Vec::<OracleSignature>::new()
                    .try_into()
                    .map_err(|_| anyhow::anyhow!("Failed to build empty signature set"))?,
                quote_header,
                feeds,
                oracle_idxs: Vec::<u8>::new()
                    .try_into()
                    .map_err(|_| anyhow::anyhow!("Failed to build empty oracle index set"))?,
                slot: parsed.slot,
                version: parsed.version,
                tail_discriminator: parsed.tail_discriminator,
            })
        }
    }
}