899 lines
28 KiB
Rust
899 lines
28 KiB
Rust
//! Program state processor
|
|
|
|
use crate::{
|
|
error::Error,
|
|
instruction::{self, Instruction},
|
|
state::{Aggregator, AggregatorConfig, Authority, Oracle, Round, Submissions},
|
|
};
|
|
|
|
// use spl_token::state;
|
|
use solana_program::{
|
|
account_info::AccountInfo,
|
|
clock::Clock,
|
|
entrypoint::ProgramResult,
|
|
msg,
|
|
program::invoke_signed,
|
|
program_error::ProgramError,
|
|
program_pack::{IsInitialized, Pack},
|
|
pubkey::Pubkey,
|
|
sysvar::{rent::Rent, Sysvar},
|
|
};
|
|
|
|
use crate::borsh_state::{BorshState, InitBorshState};
|
|
|
|
use borsh::BorshDeserialize;
|
|
|
|
struct Accounts<'a>(&'a [AccountInfo<'a>]);
|
|
|
|
impl<'a> Accounts<'a> {
|
|
fn get(&self, i: usize) -> Result<&'a AccountInfo<'a>, ProgramError> {
|
|
// fn get(&self, i: usize) -> Result<&AccountInfo, ProgramError> {
|
|
// &accounts[input.token.account as usize]
|
|
self.0.get(i).ok_or(ProgramError::NotEnoughAccountKeys)
|
|
}
|
|
|
|
fn get_rent(&self, i: usize) -> Result<Rent, ProgramError> {
|
|
Rent::from_account_info(self.get(i)?)
|
|
}
|
|
|
|
fn get_clock(&self, i: usize) -> Result<Clock, ProgramError> {
|
|
Clock::from_account_info(self.get(i)?)
|
|
}
|
|
}
|
|
|
|
struct InitializeContext<'a> {
|
|
rent: Rent,
|
|
aggregator: &'a AccountInfo<'a>,
|
|
aggregator_owner: &'a AccountInfo<'a>, // signed
|
|
round_submissions: &'a AccountInfo<'a>, // belongs_to: aggregator
|
|
answer_submissions: &'a AccountInfo<'a>, // belongs_to: aggregator
|
|
|
|
config: AggregatorConfig,
|
|
}
|
|
|
|
impl<'a> InitializeContext<'a> {
|
|
fn process(&self) -> ProgramResult {
|
|
if !self.aggregator_owner.is_signer {
|
|
return Err(ProgramError::MissingRequiredSignature);
|
|
}
|
|
|
|
self.init_submissions(self.round_submissions)?;
|
|
self.init_submissions(self.answer_submissions)?;
|
|
|
|
let mut aggregator = Aggregator::init_uninitialized(self.aggregator)?;
|
|
aggregator.is_initialized = true;
|
|
aggregator.config = self.config.clone();
|
|
aggregator.owner = self.aggregator_owner.into();
|
|
// aggregator.round_submissions = PublicKey(self.round_submissions.key.to_bytes());
|
|
aggregator.round_submissions = self.round_submissions.into();
|
|
aggregator.answer_submissions = self.answer_submissions.into();
|
|
|
|
aggregator.save_exempt(self.aggregator, &self.rent)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn init_submissions(&self, account: &AccountInfo) -> ProgramResult {
|
|
let mut submissions = Submissions::init_uninitialized(account)?;
|
|
submissions.is_initialized = true;
|
|
submissions.save_exempt(account, &self.rent)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct ConfigureContext<'a> {
|
|
aggregator: &'a AccountInfo<'a>,
|
|
aggregator_owner: &'a AccountInfo<'a>,
|
|
|
|
config: AggregatorConfig,
|
|
}
|
|
|
|
impl<'a> ConfigureContext<'a> {
|
|
fn process(&self) -> ProgramResult {
|
|
let mut aggregator = Aggregator::load_initialized(&self.aggregator)?;
|
|
aggregator.authorize(self.aggregator_owner)?;
|
|
aggregator.config = self.config.clone();
|
|
aggregator.save(self.aggregator)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct AddOracleContext<'a> {
|
|
rent: Rent,
|
|
aggregator: &'a AccountInfo<'a>,
|
|
aggregator_owner: &'a AccountInfo<'a>, // signed
|
|
oracle: &'a AccountInfo<'a>,
|
|
oracle_owner: &'a AccountInfo<'a>,
|
|
|
|
description: [u8; 32],
|
|
}
|
|
|
|
impl<'a> AddOracleContext<'a> {
|
|
fn process(&self) -> ProgramResult {
|
|
// Note: there can in fact be more oracles than max_submissions
|
|
let aggregator = Aggregator::load_initialized(self.aggregator)?;
|
|
msg!("loaded aggregator");
|
|
aggregator.authorize(self.aggregator_owner)?;
|
|
|
|
let mut oracle = Oracle::init_uninitialized(self.oracle)?;
|
|
msg!("loaded oracle");
|
|
oracle.is_initialized = true;
|
|
oracle.description = self.description;
|
|
oracle.owner = self.oracle_owner.into();
|
|
oracle.aggregator = self.aggregator.into();
|
|
oracle.save_exempt(self.oracle, &self.rent)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct RemoveOracleContext<'a> {
|
|
aggregator: &'a AccountInfo<'a>,
|
|
aggregator_owner: &'a AccountInfo<'a>, // signed
|
|
oracle: &'a AccountInfo<'a>,
|
|
}
|
|
|
|
impl<'a> RemoveOracleContext<'a> {
|
|
fn process(&self) -> ProgramResult {
|
|
let aggregator = Aggregator::load_initialized(self.aggregator)?;
|
|
aggregator.authorize(self.aggregator_owner)?;
|
|
|
|
let oracle = Oracle::load_initialized(self.oracle)?;
|
|
if oracle.aggregator.0 != self.aggregator.key.to_bytes() {
|
|
return Err(Error::AggregatorMismatch)?;
|
|
}
|
|
|
|
// Zero out the oracle account memory. This allows reuse or reclaim.
|
|
// Note: will wipe out withdrawable balance on this oracle. Too bad.
|
|
Oracle::default().save(self.oracle)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
struct SubmitContext<'a> {
|
|
clock: Clock,
|
|
aggregator: &'a AccountInfo<'a>, // write
|
|
round_submissions: &'a AccountInfo<'a>, // write
|
|
answer_submissions: &'a AccountInfo<'a>, // write
|
|
oracle: &'a AccountInfo<'a>, // write
|
|
oracle_owner: &'a AccountInfo<'a>, // signed
|
|
|
|
// NOTE: 5.84942*10^11 years even if 1 sec per round. don't bother with handling wrapparound.
|
|
round_id: u64,
|
|
value: u64,
|
|
}
|
|
|
|
impl<'a> SubmitContext<'a> {
|
|
#[inline(never)]
|
|
fn process(&self) -> ProgramResult {
|
|
let mut aggregator = Aggregator::load_initialized(self.aggregator)?;
|
|
let mut oracle = Oracle::load_initialized(self.oracle)?;
|
|
oracle.authorize(self.oracle_owner)?;
|
|
|
|
if oracle.aggregator.0 != self.aggregator.key.to_bytes() {
|
|
return Err(Error::AggregatorMismatch)?;
|
|
}
|
|
|
|
// oracle starts a new round
|
|
if self.round_id == aggregator.round.id + 1 {
|
|
self.start_new_round(&mut aggregator, &mut oracle)?;
|
|
}
|
|
|
|
// only allowed to submit in the current round (or a new round that just
|
|
// got started)
|
|
if self.round_id != aggregator.round.id {
|
|
return Err(Error::InvalidRoundID)?;
|
|
}
|
|
|
|
self.submit(&mut aggregator)?;
|
|
|
|
// credit oracle for submission
|
|
oracle.withdrawable = oracle
|
|
.withdrawable
|
|
.checked_add(aggregator.config.reward_amount)
|
|
.ok_or(Error::RewardsOverflow)?;
|
|
|
|
aggregator.save(self.aggregator)?;
|
|
oracle.save(self.oracle)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// push oracle answer to the current round. update answer if min submissions
|
|
/// had been satisfied.
|
|
fn submit(&self, aggregator: &mut Aggregator) -> ProgramResult {
|
|
let now = self.clock.slot;
|
|
|
|
let mut round_submissions = aggregator.round_submissions(self.round_submissions)?;
|
|
|
|
let (i, submission) = round_submissions
|
|
.data
|
|
.iter_mut()
|
|
.enumerate()
|
|
.find(|(_i, s)| {
|
|
// either finds a new spot to put the submission, or find a spot
|
|
// that the oracle previously submitted to.
|
|
return !s.is_initialized() || s.oracle == self.oracle.key.to_bytes();
|
|
})
|
|
.ok_or(Error::MaxSubmissionsReached)?;
|
|
|
|
let count = i + 1;
|
|
|
|
if count > aggregator.config.max_submissions as usize {
|
|
return Err(Error::MaxSubmissionsReached)?;
|
|
}
|
|
|
|
if submission.is_initialized() {
|
|
return Err(Error::OracleAlreadySubmitted)?;
|
|
}
|
|
|
|
if aggregator.round.created_at == 0 {
|
|
aggregator.round.created_at = now;
|
|
}
|
|
aggregator.round.updated_at = now;
|
|
|
|
submission.updated_at = now;
|
|
submission.value = self.value;
|
|
submission.oracle = self.oracle.key.to_bytes();
|
|
|
|
// this line is for later, but put here to deal with borrow check...
|
|
let new_submission = *submission;
|
|
|
|
round_submissions.save(self.round_submissions)?;
|
|
|
|
if count < aggregator.config.min_submissions as usize {
|
|
// not enough submissions to update answer. return now.
|
|
return Ok(());
|
|
}
|
|
|
|
// update answer if the new round reached min_submissions
|
|
let mut answer_submissions = aggregator.answer_submissions(self.answer_submissions)?;
|
|
let round = &aggregator.round;
|
|
let answer = &mut aggregator.answer;
|
|
|
|
if !answer.is_initialized() || round.id > answer.round_id {
|
|
// a new round had just been resolved. copy the current round's submissions over
|
|
answer.round_id = round.id;
|
|
answer.created_at = now;
|
|
answer.updated_at = now;
|
|
answer_submissions.data = round_submissions.data;
|
|
} else {
|
|
answer.updated_at = now;
|
|
answer_submissions.data[i] = new_submission;
|
|
}
|
|
|
|
answer.median = answer_submissions.median()?;
|
|
answer_submissions.save(self.answer_submissions)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn start_new_round(&self, aggregator: &mut Aggregator, oracle: &mut Oracle) -> ProgramResult {
|
|
let now = self.clock.slot;
|
|
|
|
if aggregator.round.id < oracle.allow_start_round {
|
|
return Err(Error::OracleNewRoundCooldown)?;
|
|
}
|
|
|
|
aggregator.round = Round {
|
|
id: self.round_id,
|
|
created_at: now,
|
|
updated_at: 0,
|
|
};
|
|
|
|
// zero the submissions of the current round
|
|
let submissions = Submissions {
|
|
is_initialized: true,
|
|
data: Default::default(),
|
|
};
|
|
submissions.save(self.round_submissions)?;
|
|
|
|
// oracle can start new round after `restart_delay` rounds
|
|
oracle.allow_start_round = self.round_id + (aggregator.config.restart_delay as u64);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// Withdraw token from reward faucet to receiver account, deducting oracle's withdrawable credit.
|
|
struct WithdrawContext<'a, 'b> {
|
|
token_program: &'a AccountInfo<'a>,
|
|
aggregator: &'a AccountInfo<'a>,
|
|
faucet: &'a AccountInfo<'a>,
|
|
faucet_owner: &'a AccountInfo<'a>, // program signed
|
|
oracle: &'a AccountInfo<'a>,
|
|
oracle_owner: &'a AccountInfo<'a>, // signed
|
|
receiver: &'a AccountInfo<'a>,
|
|
|
|
faucet_owner_seed: &'b [u8],
|
|
}
|
|
|
|
impl<'a, 'b> WithdrawContext<'a, 'b> {
|
|
fn process(&self) -> ProgramResult {
|
|
let aggregator = Aggregator::load_initialized(self.aggregator)?;
|
|
let mut oracle = Oracle::load_initialized(self.oracle)?;
|
|
oracle.authorize(&self.oracle_owner)?;
|
|
oracle.check_aggregator(self.aggregator)?;
|
|
|
|
if !aggregator
|
|
.config
|
|
.reward_token_account
|
|
.is_account(self.faucet)
|
|
{
|
|
return Err(Error::InvalidFaucet)?;
|
|
}
|
|
|
|
if oracle.withdrawable == 0 {
|
|
return Err(Error::InsufficientWithdrawable)?;
|
|
}
|
|
|
|
let amount = oracle.withdrawable;
|
|
|
|
oracle.withdrawable = 0;
|
|
oracle.save(self.oracle)?;
|
|
|
|
// The SPL Token ensures that faucet and receiver are the same type of token
|
|
let inx = spl_token::instruction::transfer(
|
|
self.token_program.key,
|
|
self.faucet.key,
|
|
self.receiver.key,
|
|
self.faucet_owner.key,
|
|
&[],
|
|
amount,
|
|
)?;
|
|
|
|
invoke_signed(
|
|
&inx,
|
|
&[
|
|
self.token_program.clone(),
|
|
self.faucet.clone(),
|
|
self.faucet_owner.clone(),
|
|
self.receiver.clone(),
|
|
],
|
|
&[&[self.faucet_owner_seed]],
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Program state handler.
|
|
pub struct Processor {}
|
|
|
|
impl Processor {
|
|
pub fn process<'a>(
|
|
_program_id: &Pubkey,
|
|
accounts: &'a [AccountInfo<'a>],
|
|
input: &[u8],
|
|
) -> ProgramResult {
|
|
let accounts = Accounts(accounts);
|
|
let instruction =
|
|
Instruction::try_from_slice(input).map_err(|_| ProgramError::InvalidInstructionData)?;
|
|
|
|
// match branches would increase stack frame, and hit the hard 4096
|
|
// frame limit. break the other branches into another function call, and
|
|
// mark it as never inline.
|
|
match instruction {
|
|
Instruction::Submit { round_id, value } => SubmitContext {
|
|
clock: accounts.get_clock(0)?,
|
|
aggregator: accounts.get(1)?,
|
|
round_submissions: accounts.get(2)?,
|
|
answer_submissions: accounts.get(3)?,
|
|
oracle: accounts.get(4)?,
|
|
oracle_owner: accounts.get(5)?,
|
|
round_id,
|
|
value,
|
|
}
|
|
.process(),
|
|
|
|
Instruction::Withdraw { faucet_owner_seed } => WithdrawContext {
|
|
token_program: accounts.get(0)?,
|
|
aggregator: accounts.get(1)?,
|
|
faucet: accounts.get(2)?, // write
|
|
faucet_owner: accounts.get(3)?, // program signed
|
|
oracle: accounts.get(4)?, // write
|
|
oracle_owner: accounts.get(5)?, // signed
|
|
receiver: accounts.get(6)?, // write
|
|
|
|
faucet_owner_seed: &faucet_owner_seed[..],
|
|
}
|
|
.process(),
|
|
instruction => process2(instruction, accounts),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline(never)]
|
|
fn process2(instruction: Instruction, accounts: Accounts) -> ProgramResult {
|
|
match instruction {
|
|
Instruction::Initialize { config } => InitializeContext {
|
|
rent: accounts.get_rent(0)?,
|
|
aggregator: accounts.get(1)?,
|
|
aggregator_owner: accounts.get(2)?,
|
|
round_submissions: accounts.get(3)?,
|
|
answer_submissions: accounts.get(4)?,
|
|
config,
|
|
}
|
|
.process(),
|
|
Instruction::Configure { config } => ConfigureContext {
|
|
aggregator: accounts.get(0)?,
|
|
aggregator_owner: accounts.get(1)?,
|
|
config,
|
|
}
|
|
.process(),
|
|
Instruction::AddOracle { description } => AddOracleContext {
|
|
rent: accounts.get_rent(0)?,
|
|
aggregator: accounts.get(1)?,
|
|
aggregator_owner: accounts.get(2)?,
|
|
oracle: accounts.get(3)?,
|
|
oracle_owner: accounts.get(4)?,
|
|
|
|
description,
|
|
}
|
|
.process(),
|
|
Instruction::RemoveOracle => RemoveOracleContext {
|
|
aggregator: accounts.get(0)?,
|
|
aggregator_owner: accounts.get(1)?,
|
|
oracle: accounts.get(2)?,
|
|
}
|
|
.process(),
|
|
_ => Err(ProgramError::InvalidInstructionData),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
use crate::instruction;
|
|
use crate::{borsh_utils, state::Submission};
|
|
use borsh::BorshSerialize;
|
|
use solana_program::sysvar;
|
|
|
|
use solana_sdk::account::{create_account, Account};
|
|
|
|
fn process<'a>(
|
|
program_id: &Pubkey,
|
|
ix: instruction::Instruction,
|
|
accounts: &'a [AccountInfo<'a>],
|
|
) -> ProgramResult {
|
|
let input = ix
|
|
.try_to_vec()
|
|
.map_err(|_| ProgramError::InvalidAccountData)?;
|
|
Processor::process(&program_id, accounts, &input)
|
|
}
|
|
|
|
fn rent_sysvar() -> TSysAccount {
|
|
TSysAccount(sysvar::rent::id(), create_account(&Rent::default(), 42))
|
|
}
|
|
|
|
fn sysclock(time: i64) -> TSysAccount {
|
|
let mut clock = Clock::default();
|
|
clock.slot = time as u64;
|
|
TSysAccount(sysvar::clock::id(), create_account(&clock, 42))
|
|
}
|
|
|
|
fn rent_exempt_balance(space: usize) -> u64 {
|
|
Rent::default().minimum_balance(space)
|
|
}
|
|
|
|
struct TAccount {
|
|
is_signer: bool,
|
|
pubkey: Pubkey,
|
|
account: Account,
|
|
}
|
|
|
|
impl TAccount {
|
|
fn new(program_id: &Pubkey, is_signer: bool) -> TAccount {
|
|
TAccount {
|
|
is_signer,
|
|
pubkey: Pubkey::new_unique(),
|
|
account: Account::new(0, 0, &program_id),
|
|
}
|
|
}
|
|
|
|
fn new_rent_exempt(program_id: &Pubkey, space: usize, is_signer: bool) -> TAccount {
|
|
TAccount {
|
|
is_signer,
|
|
pubkey: Pubkey::new_unique(),
|
|
account: Account::new(rent_exempt_balance(space), space, &program_id),
|
|
}
|
|
}
|
|
|
|
fn info(&mut self) -> AccountInfo {
|
|
AccountInfo::new(
|
|
&self.pubkey,
|
|
self.is_signer,
|
|
false,
|
|
&mut self.account.lamports,
|
|
&mut self.account.data,
|
|
&self.account.owner,
|
|
self.account.executable,
|
|
self.account.rent_epoch,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<'a> Into<AccountInfo<'a>> for &'a mut TAccount {
|
|
fn into(self) -> AccountInfo<'a> {
|
|
self.info()
|
|
}
|
|
}
|
|
|
|
struct TSysAccount(Pubkey, Account);
|
|
impl<'a> Into<AccountInfo<'a>> for &'a mut TSysAccount {
|
|
fn into(self) -> AccountInfo<'a> {
|
|
AccountInfo::new(
|
|
&self.0,
|
|
false,
|
|
false,
|
|
&mut self.1.lamports,
|
|
&mut self.1.data,
|
|
&self.1.owner,
|
|
self.1.executable,
|
|
self.1.rent_epoch,
|
|
)
|
|
}
|
|
}
|
|
|
|
struct TAggregator {
|
|
aggregator: TAccount,
|
|
aggregator_owner: TAccount,
|
|
round_submissions: TAccount,
|
|
answer_submissions: TAccount,
|
|
}
|
|
|
|
fn create_aggregator(program_id: &Pubkey) -> Result<TAggregator, ProgramError> {
|
|
let mut rent_sysvar = rent_sysvar();
|
|
let mut aggregator = TAccount::new_rent_exempt(
|
|
&program_id,
|
|
borsh_utils::get_packed_len::<Aggregator>(),
|
|
false,
|
|
);
|
|
let mut aggregator_owner = TAccount::new(&program_id, true);
|
|
let mut round_submissions = TAccount::new_rent_exempt(
|
|
&program_id,
|
|
borsh_utils::get_packed_len::<Submissions>(),
|
|
false,
|
|
);
|
|
let mut answer_submissions = TAccount::new_rent_exempt(
|
|
&program_id,
|
|
borsh_utils::get_packed_len::<Submissions>(),
|
|
false,
|
|
);
|
|
|
|
process(
|
|
&program_id,
|
|
instruction::Instruction::Initialize {
|
|
config: AggregatorConfig {
|
|
decimals: 8,
|
|
description: [0u8; 32],
|
|
min_submissions: 2,
|
|
max_submissions: 2,
|
|
restart_delay: 1,
|
|
reward_amount: 10,
|
|
|
|
..AggregatorConfig::default()
|
|
},
|
|
},
|
|
vec![
|
|
(&mut rent_sysvar).into(),
|
|
(&mut aggregator).into(),
|
|
(&mut aggregator_owner).into(),
|
|
(&mut round_submissions).into(),
|
|
(&mut answer_submissions).into(),
|
|
]
|
|
.as_slice(),
|
|
)?;
|
|
|
|
Ok(TAggregator {
|
|
aggregator,
|
|
aggregator_owner,
|
|
round_submissions,
|
|
answer_submissions,
|
|
})
|
|
}
|
|
|
|
fn create_oracle(
|
|
program_id: &Pubkey,
|
|
aggregator: &mut TAccount,
|
|
aggregator_owner: &mut TAccount,
|
|
) -> Result<(TAccount, TAccount), ProgramError> {
|
|
let mut rent_sysvar = rent_sysvar();
|
|
let mut oracle =
|
|
TAccount::new_rent_exempt(&program_id, borsh_utils::get_packed_len::<Oracle>(), false);
|
|
let mut oracle_owner = TAccount::new(&program_id, true);
|
|
|
|
process(
|
|
&program_id,
|
|
instruction::Instruction::AddOracle {
|
|
description: [0xab; 32],
|
|
},
|
|
vec![
|
|
(&mut rent_sysvar).into(),
|
|
aggregator.into(),
|
|
aggregator_owner.into(),
|
|
(&mut oracle).into(),
|
|
(&mut oracle_owner).into(),
|
|
]
|
|
.as_slice(),
|
|
)?;
|
|
|
|
Ok((oracle, oracle_owner))
|
|
}
|
|
|
|
#[test]
|
|
fn test_intialize() -> ProgramResult {
|
|
let program_id = Pubkey::new_unique();
|
|
create_aggregator(&program_id)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_configure() -> ProgramResult {
|
|
let program_id = Pubkey::new_unique();
|
|
let TAggregator {
|
|
mut aggregator,
|
|
mut aggregator_owner,
|
|
..
|
|
} = create_aggregator(&program_id)?;
|
|
|
|
process(
|
|
&program_id,
|
|
instruction::Instruction::Configure {
|
|
config: AggregatorConfig {
|
|
reward_amount: 1000,
|
|
..AggregatorConfig::default()
|
|
},
|
|
},
|
|
vec![(&mut aggregator).into(), (&mut aggregator_owner).into()].as_slice(),
|
|
)?;
|
|
|
|
let aggregator_state = Aggregator::load_initialized(&aggregator.info())?;
|
|
assert_eq!(aggregator_state.config.reward_amount, 1000);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_and_remove_oracle() -> ProgramResult {
|
|
let program_id = Pubkey::new_unique();
|
|
|
|
let TAggregator {
|
|
mut aggregator,
|
|
mut aggregator_owner,
|
|
..
|
|
} = create_aggregator(&program_id)?;
|
|
let (mut oracle, _oracle_owner) =
|
|
create_oracle(&program_id, &mut aggregator, &mut aggregator_owner)?;
|
|
|
|
process(
|
|
&program_id,
|
|
instruction::Instruction::RemoveOracle {},
|
|
vec![
|
|
(&mut aggregator).into(),
|
|
(&mut aggregator_owner).into(),
|
|
(&mut oracle).into(),
|
|
]
|
|
.as_slice(),
|
|
)?;
|
|
|
|
// println!("{}", hex::encode(oracle.account.data));
|
|
Ok(())
|
|
}
|
|
|
|
struct SubmitTestFixture {
|
|
program_id: Pubkey,
|
|
t_aggregator: TAggregator,
|
|
}
|
|
|
|
impl SubmitTestFixture {
|
|
fn submit(
|
|
&mut self,
|
|
oracle: &mut TAccount,
|
|
oracle_owner: &mut TAccount,
|
|
time: u64,
|
|
round_id: u64,
|
|
value: u64,
|
|
) -> Result<Aggregator, ProgramError> {
|
|
let mut clock = sysclock(time as i64);
|
|
|
|
process(
|
|
&self.program_id,
|
|
instruction::Instruction::Submit { round_id, value },
|
|
vec![
|
|
(&mut clock).into(),
|
|
self.t_aggregator.aggregator.info(),
|
|
self.t_aggregator.round_submissions.info(),
|
|
self.t_aggregator.answer_submissions.info(),
|
|
oracle.into(),
|
|
oracle_owner.into(),
|
|
]
|
|
.as_slice(),
|
|
)?;
|
|
|
|
Aggregator::load_initialized(&self.t_aggregator.aggregator.info())
|
|
}
|
|
|
|
fn aggregator(&mut self) -> Result<Aggregator, ProgramError> {
|
|
Aggregator::load_initialized(&self.t_aggregator.aggregator.info())
|
|
}
|
|
|
|
fn create_oracle(&mut self) -> Result<(TAccount, TAccount), ProgramError> {
|
|
create_oracle(
|
|
&self.program_id,
|
|
&mut self.t_aggregator.aggregator,
|
|
&mut self.t_aggregator.aggregator_owner,
|
|
)
|
|
}
|
|
|
|
fn round_submission(&mut self, i: usize) -> Result<Submission, ProgramError> {
|
|
Ok(self.round_submissions()?.data[i])
|
|
}
|
|
|
|
fn round_submissions(&mut self) -> Result<Submissions, ProgramError> {
|
|
self.aggregator()?
|
|
.round_submissions(&self.t_aggregator.round_submissions.info())
|
|
}
|
|
|
|
fn answer_submission(&mut self, i: usize) -> Result<Submission, ProgramError> {
|
|
Ok(self.answer_submissions()?.data[i])
|
|
}
|
|
|
|
fn answer_submissions(&mut self) -> Result<Submissions, ProgramError> {
|
|
self.aggregator()?
|
|
.answer_submissions(&self.t_aggregator.answer_submissions.info())
|
|
}
|
|
}
|
|
#[test]
|
|
fn test_submit() -> ProgramResult {
|
|
let program_id = Pubkey::new_unique();
|
|
|
|
let mut tt = SubmitTestFixture {
|
|
program_id,
|
|
t_aggregator: create_aggregator(&program_id)?,
|
|
};
|
|
|
|
let (mut oracle, mut oracle_owner) = tt.create_oracle()?;
|
|
let (mut oracle2, mut oracle_owner2) = tt.create_oracle()?;
|
|
let (mut oracle3, mut oracle_owner3) = tt.create_oracle()?;
|
|
|
|
let time = 100;
|
|
let agr = tt.submit(&mut oracle, &mut oracle_owner, time, 0, 1)?;
|
|
let oracle_state = Oracle::load_initialized(&oracle.info())?;
|
|
let sub = tt.round_submission(0)?;
|
|
let round = &agr.round;
|
|
assert_eq!(oracle_state.withdrawable, 10);
|
|
assert_eq!(round.created_at, time);
|
|
assert_eq!(round.updated_at, time);
|
|
assert_eq!(sub.oracle, oracle.pubkey.to_bytes());
|
|
assert_eq!(sub.value, 1);
|
|
assert_eq!(sub.updated_at, 100);
|
|
assert_eq!(agr.answer.is_initialized(), false);
|
|
|
|
// test: should fail with repeated submission
|
|
assert_eq!(
|
|
tt.submit(&mut oracle, &mut oracle_owner, time + 10, 0, 2)
|
|
.map_err(Error::from),
|
|
Err(Error::OracleAlreadySubmitted),
|
|
"should fail if oracle submits repeatedly in the same round"
|
|
);
|
|
|
|
let old_time = time;
|
|
let time = 200;
|
|
let agr = tt.submit(&mut oracle2, &mut oracle_owner2, time, 0, 2)?;
|
|
let oracle_state = Oracle::load_initialized(&oracle.info())?;
|
|
let sub = tt.round_submission(1)?;
|
|
let round = &agr.round;
|
|
assert_eq!(oracle_state.withdrawable, 10);
|
|
assert_eq!(round.created_at, old_time);
|
|
assert_eq!(round.updated_at, time);
|
|
assert_eq!(sub.oracle, oracle2.pubkey.to_bytes());
|
|
assert_eq!(sub.value, 2);
|
|
assert_eq!(sub.updated_at, time);
|
|
|
|
// // test: answer resolved when min_submissions is reached
|
|
let answer = &agr.answer;
|
|
assert_eq!(answer.is_initialized(), true);
|
|
assert_eq!(answer.updated_at, time);
|
|
assert_eq!(answer.created_at, time);
|
|
|
|
let answer_submissions = tt.answer_submissions()?;
|
|
let round_submissions = tt.round_submissions()?;
|
|
assert_eq!(answer_submissions, round_submissions);
|
|
|
|
// test: max submission reached
|
|
assert_eq!(
|
|
tt.submit(&mut oracle3, &mut oracle_owner3, time + 10, 0, 2)
|
|
.map_err(Error::from),
|
|
Err(Error::MaxSubmissionsReached),
|
|
);
|
|
|
|
// test: start new round
|
|
let time = 300;
|
|
let agr = tt.submit(&mut oracle, &mut oracle_owner, time, 1, 10)?;
|
|
let oracle_state = Oracle::load_initialized(&oracle.info())?;
|
|
let sub = tt.round_submission(0)?;
|
|
let round = &agr.round;
|
|
assert_eq!(oracle_state.withdrawable, 20);
|
|
assert_eq!(round.id, 1);
|
|
assert_eq!(round.created_at, time);
|
|
assert_eq!(round.updated_at, time);
|
|
assert_eq!(sub.oracle, oracle.pubkey.to_bytes());
|
|
assert_eq!(sub.value, 10);
|
|
assert_eq!(sub.updated_at, time);
|
|
assert_eq!(
|
|
tt.round_submission(1)?.is_initialized(),
|
|
false,
|
|
"other submissions should've been zero after starting a new round"
|
|
);
|
|
|
|
// the last round answer should be reserved
|
|
let answer = &agr.answer;
|
|
assert_eq!(answer.is_initialized(), true);
|
|
assert_eq!(answer.round_id, 0);
|
|
assert_eq!(answer.updated_at, 200);
|
|
assert_eq!(answer.created_at, 200);
|
|
|
|
// test: oracle cannot immediately start a new round
|
|
assert_eq!(
|
|
tt.submit(&mut oracle, &mut oracle_owner, time + 10, 2, 2)
|
|
.map_err(Error::from),
|
|
Err(Error::OracleNewRoundCooldown),
|
|
);
|
|
|
|
// test: resolve a new round
|
|
let time = 400;
|
|
let agr = tt.submit(&mut oracle2, &mut oracle_owner2, time, 1, 20)?;
|
|
let sub = tt.round_submission(1)?;
|
|
|
|
assert_eq!(sub.oracle, oracle2.pubkey.to_bytes());
|
|
assert_eq!(sub.value, 20);
|
|
assert_eq!(sub.updated_at, time);
|
|
|
|
let answer = &agr.answer;
|
|
assert_eq!(answer.is_initialized(), true);
|
|
assert_eq!(answer.round_id, 1);
|
|
assert_eq!(answer.updated_at, time);
|
|
assert_eq!(answer.created_at, time);
|
|
assert_eq!(answer.median, 15);
|
|
|
|
assert_eq!(tt.answer_submission(0)?.value, 10);
|
|
assert_eq!(tt.answer_submission(1)?.value, 20);
|
|
|
|
let time = 500;
|
|
// let oracle 2 start a new round
|
|
let agr = tt.submit(&mut oracle2, &mut oracle_owner2, time, 2, 200)?;
|
|
let round = &agr.round;
|
|
assert_eq!(round.id, 2);
|
|
|
|
let agr = tt.submit(&mut oracle, &mut oracle_owner, time, 3, 200)?;
|
|
let round = &agr.round;
|
|
assert_eq!(round.id, 3);
|
|
|
|
let agr = tt.submit(&mut oracle2, &mut oracle_owner2, time, 4, 200)?;
|
|
let round = &agr.round;
|
|
assert_eq!(round.id, 4);
|
|
|
|
// InvalidRoundID
|
|
assert_eq!(
|
|
tt.submit(&mut oracle, &mut oracle_owner, time + 10, 10, 1000)
|
|
.map_err(Error::from),
|
|
Err(Error::InvalidRoundID),
|
|
"should only be able to start a round with current_round.id + 1"
|
|
);
|
|
|
|
assert_eq!(
|
|
tt.submit(&mut oracle3, &mut oracle_owner3, time + 10, 3, 1000)
|
|
.map_err(Error::from),
|
|
Err(Error::InvalidRoundID),
|
|
"should not be able to submit answer to previous rounds"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
}
|