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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
use crate::*;
use rust_decimal::Decimal;
use sha2::{Digest, Sha256};
use solana_program::pubkey::Pubkey;
use solana_program::clock::Clock;
use std::cell::Ref;
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) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.value, PRECISION))
}
/// The standard deviation of the submissions needed for quorom size
pub fn std_dev(&self) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.std_dev, PRECISION))
}
/// The mean of the submissions needed for quorom size
pub fn mean(&self) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.mean, PRECISION))
}
/// The range of the submissions needed for quorom size
pub fn range(&self) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.range, PRECISION))
}
/// The minimum value of the submissions needed for quorom size
pub fn min_value(&self) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.min_value, PRECISION))
}
/// The maximum value of the submissions needed for quorom size
pub fn max_value(&self) -> Option<Decimal> {
if self.slot == 0 {
return None;
}
Some(Decimal::from_i128_with_scale(self.max_value, PRECISION))
}
pub fn result_slot(&self) -> Option<u64> {
if self.slot == 0 {
return None;
}
Some(self.slot)
}
pub fn min_slot(&self) -> Option<u64> {
if self.slot == 0 {
return None;
}
Some(self.min_slot)
}
pub fn max_slot(&self) -> Option<u64> {
if self.slot == 0 {
return None;
}
Some(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 {
pub fn discriminator() -> [u8; 8] {
[196, 27, 108, 196, 10, 215, 219, 40]
}
pub fn parse<'info>(
data: Ref<'info, &mut [u8]>,
) -> Result<Ref<'info, Self>, OnDemandError> {
if data.len() < Self::discriminator().len() {
return Err(OnDemandError::InvalidDiscriminator);
}
let mut disc_bytes = [0u8; 8];
disc_bytes.copy_from_slice(&data[..8]);
if disc_bytes != Self::discriminator() {
return Err(OnDemandError::InvalidDiscriminator);
}
Ok(Ref::map(data, |data: &&mut [u8]| {
bytemuck::from_bytes(&data[8..std::mem::size_of::<Self>() + 8])
}))
}
/// Generate a checksum for the given feed hash, result, slothash, max_variance and min_responses
/// This is signed by the oracle and used to verify that the data submitted by the oracles is valid.
pub fn generate_checksum(&self, result: i128, slothash: [u8; 32]) -> [u8; 32] {
Self::generate_checksum_inner(
self.queue,
self.feed_hash,
result,
slothash,
self.max_variance,
self.min_responses,
)
}
/// Generate a checksum for the given feed hash, result, slothash, max_variance and min_responses
/// This is signed by the oracle and used to verify that the data submitted by the oracles is valid.
pub fn generate_checksum_inner(
queue: Pubkey,
feed_hash: [u8; 32],
result: i128,
slothash: [u8; 32],
max_variance: u64,
min_responses: u32,
) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(queue.to_bytes());
hasher.update(feed_hash);
hasher.update(result.to_le_bytes());
hasher.update(slothash);
hasher.update(max_variance.to_le_bytes());
hasher.update(min_responses.to_le_bytes());
hasher.finalize().to_vec().try_into().unwrap()
}
/// Generate a checksum for the given feed hash, result, slothash, max_variance and min_responses
/// This is signed by the oracle and used to verify that the data submitted by the oracles is valid.
pub fn generate_checksum_with_timestamp(
queue: Pubkey,
feed_hash: [u8; 32],
result: i128,
slothash: [u8; 32],
max_variance: u64,
min_responses: u32,
timestamp: u64,
) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(queue.to_bytes());
hasher.update(feed_hash);
hasher.update(result.to_le_bytes());
hasher.update(slothash);
hasher.update(max_variance.to_le_bytes());
hasher.update(min_responses.to_le_bytes());
hasher.update(timestamp.to_le_bytes());
hasher.finalize().to_vec().try_into().unwrap()
}
/// **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) -> Option<Decimal> {
self.result.value()
}
/// The standard deviation of the submissions needed for quorom size
pub fn std_dev(&self) -> Option<Decimal> {
self.result.std_dev()
}
/// The mean of the submissions needed for quorom size
pub fn mean(&self) -> Option<Decimal> {
self.result.mean()
}
/// The range of the submissions needed for quorom size
pub fn range(&self) -> Option<Decimal> {
self.result.range()
}
/// The minimum value of the submissions needed for quorom size
pub fn min_value(&self) -> Option<Decimal> {
self.result.min_value()
}
/// The maximum value of the submissions needed for quorom size
pub fn max_value(&self) -> Option<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])
}