1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
use crate::*;
use rust_decimal::Decimal;
use sha2::{Digest, Sha256};
use num::integer::Roots;
use solana_program::pubkey::Pubkey;
use solana_program::clock::Clock;
pub const PRECISION: u32 = 18;
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct CurrentResult {
/// The median value of the submissions needed for quorom size
pub value: i128,
/// The standard deviation of the submissions needed for quorom size
pub std_dev: i128,
/// The mean of the submissions needed for quorom size
pub mean: i128,
/// The range of the submissions needed for quorom size
pub range: i128,
/// The minimum value of the submissions needed for quorom size
pub min_value: i128,
/// The maximum value of the submissions needed for quorom size
pub max_value: i128,
pub padding1: [u8; 8],
/// The slot at which this value was signed.
pub slot: u64,
/// The slot at which the first considered submission was made
pub min_slot: u64,
/// The slot at which the last considered submission was made
pub max_slot: u64,
}
impl CurrentResult {
/// The median value of the submissions needed for quorom size
pub fn value(&self) -> Decimal {
Decimal::from_i128_with_scale(self.value, PRECISION)
}
/// The standard deviation of the submissions needed for quorom size
pub fn std_dev(&self) -> Decimal {
Decimal::from_i128_with_scale(self.std_dev, PRECISION)
}
/// The mean of the submissions needed for quorom size
pub fn mean(&self) -> Decimal {
Decimal::from_i128_with_scale(self.mean, PRECISION)
}
/// The range of the submissions needed for quorom size
pub fn range(&self) -> Decimal {
Decimal::from_i128_with_scale(self.range, PRECISION)
}
/// The minimum value of the submissions needed for quorom size
pub fn min_value(&self) -> Decimal {
Decimal::from_i128_with_scale(self.min_value, PRECISION)
}
/// The maximum value of the submissions needed for quorom size
pub fn max_value(&self) -> Decimal {
Decimal::from_i128_with_scale(self.max_value, PRECISION)
}
pub fn result_slot(&self) -> u64 {
self.slot
}
pub fn min_slot(&self) -> u64 {
self.min_slot
}
pub fn max_slot(&self) -> u64 {
self.max_slot
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct OracleSubmission {
/// The public key of the oracle that submitted this value.
pub oracle: Pubkey,
/// The slot at which this value was signed.
pub slot: u64,
padding1: [u8; 8],
/// The value that was submitted.
pub value: i128,
}
/// A representation of the data in a pull feed account.
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct PullFeedAccountData {
/// The oracle submissions for this feed.
pub submissions: [OracleSubmission; 32],
/// The public key of the authority that can update the feed hash that
/// this account will use for registering updates.
pub authority: Pubkey,
/// The public key of the queue which oracles must be bound to in order to
/// submit data to this feed.
pub queue: Pubkey,
/// SHA-256 hash of the job schema oracles will execute to produce data
/// for this feed.
pub feed_hash: [u8; 32],
/// The slot at which this account was initialized.
pub initialized_at: i64,
pub permissions: u64,
pub max_variance: u64,
pub min_responses: u32,
pub name: [u8; 32],
_padding1: [u8; 3],
pub sample_size: u8,
pub last_update_timestamp: i64,
pub lut_slot: u64,
pub ipfs_hash: [u8; 32], // deprecated
pub result: CurrentResult,
pub max_staleness: u32,
_ebuf4: [u8; 20],
_ebuf3: [u8; 24],
_ebuf2: [u8; 256],
_ebuf1: [u8; 512],
}
impl OracleSubmission {
pub fn is_empty(&self) -> bool {
self.slot == 0
}
pub fn value(&self) -> Decimal {
Decimal::from_i128_with_scale(self.value, PRECISION)
}
}
impl PullFeedAccountData {
/// **method**
/// get_value
/// Returns the median value of the submissions in the last `max_staleness` slots.
/// If there are fewer than `min_samples` submissions, returns an error.
/// **arguments**
/// * `clock` - the clock to use for the current slot
/// * `max_staleness` - the maximum number of slots to consider
/// * `min_samples` - the minimum number of samples required to return a value
/// **returns**
/// * `Ok(Decimal)` - the median value of the submissions in the last `max_staleness` slots
pub fn get_value(
&self,
clock: &Clock,
max_staleness: u64,
min_samples: u32,
only_positive: bool,
) -> Result<Decimal, OnDemandError> {
let submissions = self
.submissions
.iter()
.take_while(|s| !s.is_empty())
.filter(|s| s.slot > clock.slot - max_staleness)
.collect::<Vec<_>>();
if submissions.len() < min_samples as usize {
return Err(OnDemandError::NotEnoughSamples);
}
let median =
lower_bound_median(&mut submissions.iter().map(|s| s.value).collect::<Vec<_>>())
.ok_or(OnDemandError::NotEnoughSamples)?;
if only_positive && median <= 0 {
return Err(OnDemandError::IllegalFeedValue);
}
Ok(Decimal::from_i128_with_scale(median, PRECISION))
}
/// The median value of the submissions needed for quorom size
pub fn value(&self) -> Decimal {
self.result.value()
}
/// The standard deviation of the submissions needed for quorom size
pub fn std_dev(&self) -> Decimal {
self.result.std_dev()
}
/// The mean of the submissions needed for quorom size
pub fn mean(&self) -> Decimal {
self.result.mean()
}
/// The range of the submissions needed for quorom size
pub fn range(&self) -> Decimal {
self.result.range()
}
/// The minimum value of the submissions needed for quorom size
pub fn min_value(&self) -> Decimal {
self.result.min_value()
}
/// The maximum value of the submissions needed for quorom size
pub fn max_value(&self) -> Decimal {
self.result.max_value()
}
}
// takes the rounded down median of a list of numbers
pub fn lower_bound_median(numbers: &mut Vec<i128>) -> Option<i128> {
numbers.sort(); // Sort the numbers in ascending order.
let len = numbers.len();
if len == 0 {
return None; // Return None for an empty list.
}
Some(numbers[len / 2])
}