Function handler

pyth_stats/programs/pyth_stats/src/instructions/calc.rs:65–180

(ctx: Context<Calc<'info>>)

}

pub fn handler<'info>(ctx: Context<Calc<'info>>) -> Result<ThreadResponse> {
    // get accounts
    let avg_buffer_acc = ctx.accounts.avg_buffer.as_ref();
    let price_buffer_acc = ctx.accounts.price_buffer.as_ref();
    let price_feed = &ctx.accounts.price_feed;
    let stat = &mut ctx.accounts.stat;
    let thread = &ctx.accounts.thread;
    let time_series_acc = ctx.accounts.time_series.as_ref();

    // load mut entries
    let mut avg_buffer = load_entries_mut::<AvgBuffer, i64>(avg_buffer_acc.try_borrow_mut_data()?).unwrap();
    let mut price_buffer = load_entries_mut::<PriceBuffer, i64>(price_buffer_acc.try_borrow_mut_data()?).unwrap();
    let mut time_series = load_entries_mut::<TimeSeries, i64>(time_series_acc.try_borrow_mut_data()?).unwrap();

    let mut next_instruction: Option<InstructionData> = None;

    match load_price_feed_from_account_info(&price_feed.to_account_info()) {
        Ok(price_feed) => { 
            // Load Pyth price fee. 
            let price = price_feed.get_price_unchecked();

            // Starting at the tail, start nullifying data points older than the lookback window.
            // TODO This is a worst-case linear operation over a large time_series. 
            //      Watch out for exceeding compute unit limits. Since this is a threaded instruction,
            //      we can run it as an infinite loop until we've cleared out all the old data.
            match stat.head {
                None => {}, // Noop
                Some(head) => {
                    let mut tail = (head - stat.sample_count as i64 + 1).rem_euclid(stat.buffer_size as i64);
                    while stat.sample_count > 0 && time_series[tail as usize] < price.publish_time - stat.lookback_window {
                        stat.sample_sum -= price_buffer[tail as usize];
                        stat.sample_count -= 1;
                        price_buffer[tail as usize] = i64::default();
                        avg_buffer[tail as usize] = i64::default();
                        time_series[tail as usize] = i64::default();
                        tail = (tail + 1).rem_euclid(stat.buffer_size as i64);
                    }
                }
            }
            
            // Insert the new data point, and update head. 
            match stat.head {
                // no data present
                None => {
                    stat.head = Some(0);
                    time_series[0] = price.publish_time;
                    price_buffer[0] = price.price;
                    stat.sample_count += 1;
                },
                // data present
                Some(head) => {
                    // update head idx for next insertion
                    stat.head = Some((head + 1).rem_euclid(stat.buffer_size as i64));

                    // If the buffer is not yet full, increment the sample count. 
                    // Otherwise, subtract the data value that's about to be overwritten from the sum.  
                    if stat.sample_count < stat.buffer_size {
                        stat.sample_count += 1