use std::sync::Arc;
use alloy::primitives::U256;
use serde::{Deserialize, Serialize};
use tycho_common::simulation::errors::SimulationError;
use crate::evm::protocol::safe_math::{safe_add_u256, safe_div_u256, safe_mul_u256, safe_sub_u256};
#[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Observation {
pub(crate) block_timestamp: u32,
pub(crate) tick_cumulative: i64,
pub(crate) seconds_per_liquidity_cumulative_x128: U256,
pub(crate) initialized: bool,
}
impl Observation {
pub fn from_attribute(bytes: &[u8]) -> Result<Self, SimulationError> {
if bytes.len() > 32 {
return Err(SimulationError::FatalError(format!(
"Invalid observation length: expected at most 32 bytes, got {}",
bytes.len()
)));
}
let value = U256::from_be_slice(bytes);
let block_timestamp: u32 = (value & U256::from((1u64 << 32) - 1)).to::<u32>();
let tick_bits: u64 = ((value >> 32u32) & U256::from((1u64 << 56) - 1)).to::<u64>();
let tick_bits_signed = i64::try_from(tick_bits).map_err(|e| {
SimulationError::FatalError(format!("Observation tick bits {tick_bits}: {e}"))
})?;
let tick_cumulative: i64 = if (tick_bits & (1 << 55)) != 0 {
tick_bits_signed - (1i64 << 56)
} else {
tick_bits_signed
};
let seconds_per_liquidity_cumulative_x128 =
(value >> 88) & ((U256::from(1) << 160) - U256::from(1));
let initialized = ((value >> 248) & U256::from(1)) == U256::from(1);
Ok(Self {
block_timestamp,
tick_cumulative,
seconds_per_liquidity_cumulative_x128,
initialized,
})
}
}
const RING_SLOTS: u16 = u16::MAX;
pub fn observation_slot(key: &str) -> Option<Result<u16, String>> {
let slot = key.strip_prefix("observations/")?;
Some(match slot.parse::<u16>() {
Ok(slot) if slot < RING_SLOTS => Ok(slot),
Ok(slot) => Err(format!("{key}: slot {slot} is past the {RING_SLOTS}-slot ring")),
Err(err) => Err(format!("{key}: {err}")),
})
}
#[derive(Debug)]
pub enum ObserveError {
TooOld,
Data(SimulationError),
}
impl From<SimulationError> for ObserveError {
fn from(err: SimulationError) -> Self {
Self::Data(err)
}
}
#[derive(Clone, Debug)]
pub struct Observations {
ring: Arc<Vec<Observation>>,
overlay: Vec<(usize, Observation)>,
}
#[derive(Clone, Serialize, Deserialize)]
struct ObservationsData {
observations: Vec<Observation>,
}
impl From<ObservationsData> for Observations {
fn from(data: ObservationsData) -> Self {
Self::new(data.observations)
}
}
impl From<Observations> for ObservationsData {
fn from(observations: Observations) -> Self {
let merged = (0..observations.len())
.map(|idx| observations.slot(idx))
.collect();
Self { observations: merged }
}
}
impl Serialize for Observations {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
ObservationsData::from(self.clone()).serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Observations {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
ObservationsData::deserialize(deserializer).map(Self::from)
}
}
impl PartialEq for Observations {
fn eq(&self, other: &Self) -> bool {
if self.shares_ring_with(other) && self.overlay == other.overlay {
return true;
}
self.len() == other.len() && (0..self.len()).all(|idx| self.slot(idx) == other.slot(idx))
}
}
impl Eq for Observations {}
impl Observations {
pub fn new(observations: Vec<Observation>) -> Self {
Self { ring: Arc::new(observations), overlay: Vec::new() }
}
pub fn shares_ring_with(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.ring, &other.ring)
}
fn len(&self) -> usize {
let overlaid = self
.overlay
.iter()
.map(|(idx, _)| idx + 1)
.max()
.unwrap_or(0);
self.ring.len().max(overlaid)
}
fn at(&self, idx: usize) -> Option<Observation> {
if let Some((_, observation)) = self
.overlay
.iter()
.find(|(slot, _)| *slot == idx)
{
return Some(*observation);
}
if let Some(observation) = self.ring.get(idx) {
return Some(*observation);
}
(idx < self.len()).then(Observation::default)
}
fn overlay_write(&mut self, idx: usize, observation: Observation) {
match self
.overlay
.iter_mut()
.find(|(slot, _)| *slot == idx)
{
Some((_, existing)) => *existing = observation,
None => self.overlay.push((idx, observation)),
}
}
fn merge_overlay(&mut self) {
if self.overlay.is_empty() {
return;
}
let len = self.len();
let ring = Arc::make_mut(&mut self.ring);
ring.resize(len, Observation::default());
for (idx, observation) in self.overlay.drain(..) {
ring[idx] = observation;
}
}
fn observation_index_err(&self, idx: usize, index: u16, cardinality: u16) -> SimulationError {
SimulationError::FatalError(format!(
"Observation index {} out of bounds (len={}), index={} cardinality={}",
idx,
self.len(),
index,
cardinality
))
}
pub(crate) fn from_words<'a>(
words: impl IntoIterator<Item = (u16, &'a [u8])>,
) -> Result<Self, SimulationError> {
let mut ring = Self::new(Vec::new());
for (slot, word) in words {
let observation = Observation::from_attribute(word).map_err(|err| {
SimulationError::FatalError(format!("Observation slot {slot}: {err}"))
})?;
if observation.initialized {
ring.place(usize::from(slot), observation);
}
}
Ok(ring)
}
pub(crate) fn into_slots(mut self) -> Vec<Observation> {
self.merge_overlay();
Arc::unwrap_or_clone(self.ring)
}
pub fn upsert_observation(&mut self, slot: u16, bytes: &[u8]) -> Result<(), SimulationError> {
self.place(usize::from(slot), Observation::from_attribute(bytes)?);
Ok(())
}
fn place(&mut self, idx: usize, observation: Observation) {
let observation =
if observation.initialized { observation } else { Observation::default() };
self.merge_overlay();
if idx >= self.ring.len() && !observation.initialized {
return;
}
let ring = Arc::make_mut(&mut self.ring);
if idx >= ring.len() {
ring.resize(idx + 1, Observation::default());
}
ring[idx] = observation;
}
pub fn write(
&mut self,
index: u16,
timestamp: u32,
tick: i32,
liquidity: u128,
cardinality: u16,
) -> Result<u16, SimulationError> {
if cardinality == 0 {
return Err(SimulationError::FatalError("Cardinality must be > 0".to_string()));
}
let idx = index as usize;
let Some(last) = self.at(idx) else {
return Err(self.observation_index_err(idx, index, cardinality));
};
if last.block_timestamp == timestamp {
return Ok(index);
}
let next_index = (index + 1) % cardinality;
let observation = transform(&last, timestamp, tick, liquidity)?;
self.overlay_write(usize::from(next_index), observation);
Ok(next_index)
}
pub fn get(&self, index: u16) -> Option<Observation> {
self.at(index as usize)
}
fn slot(&self, idx: usize) -> Observation {
self.at(idx).unwrap_or_default()
}
pub fn timestamp_at(&self, index: u16, cardinality: u16) -> Result<u32, SimulationError> {
let idx = index as usize;
match self.at(idx) {
Some(observation) => Ok(observation.block_timestamp),
None => Err(self.observation_index_err(idx, index, cardinality)),
}
}
pub(crate) fn observe(
&self,
time: u32,
seconds_agos: &[u32],
tick: i32,
index: u16,
liquidity: u128,
cardinality: u16,
) -> Result<(Vec<i64>, Vec<U256>), ObserveError> {
if cardinality == 0 {
return Err(SimulationError::FatalError("Cardinality must be > 0".to_string()).into());
}
let mut tick_cumulatives = Vec::with_capacity(seconds_agos.len());
let mut seconds_per_liquidity_cumulative_x128s = Vec::with_capacity(seconds_agos.len());
for &seconds_ago in seconds_agos {
let (tick_cum, sec_liq) =
self.observe_single(time, seconds_ago, tick, index, liquidity, cardinality)?;
tick_cumulatives.push(tick_cum);
seconds_per_liquidity_cumulative_x128s.push(sec_liq);
}
Ok((tick_cumulatives, seconds_per_liquidity_cumulative_x128s))
}
pub fn binary_search(
&self,
time: u32,
target: u32,
index: u16,
cardinality: u16,
) -> Result<(Observation, Observation), ObserveError> {
if self.len() == 0 {
return Err(SimulationError::FatalError("No observations available".to_string()).into());
}
let mut l = (index as usize + 1) % cardinality as usize;
let mut r = l + cardinality as usize - 1;
while l <= r {
let i = (l + r) / 2;
let before_or_at = self.slot(i % cardinality as usize);
if !before_or_at.initialized {
l = i + 1;
continue;
}
let at_or_after = self.slot((i + 1) % cardinality as usize);
let target_at_or_after = lte(time, before_or_at.block_timestamp, target);
if target_at_or_after && lte(time, target, at_or_after.block_timestamp) {
return Ok((before_or_at, at_or_after));
}
if !target_at_or_after {
if i == 0 {
break;
}
r = i - 1;
} else {
l = i + 1;
}
}
Err(SimulationError::FatalError(
"Binary search failed — inconsistent oracle data".to_string(),
)
.into())
}
pub fn get_surrounding_observations(
&self,
time: u32,
target: u32,
tick: i32,
index: u16,
liquidity: u128,
cardinality: u16,
) -> Result<(Observation, Observation), ObserveError> {
let idx = index as usize;
let Some(mut before_or_at) = self.at(idx) else {
return Err(self
.observation_index_err(idx, index, cardinality)
.into());
};
if lte(time, before_or_at.block_timestamp, target) {
if before_or_at.block_timestamp == target {
return Ok((before_or_at, before_or_at));
}
return Ok((before_or_at, transform(&before_or_at, target, tick, liquidity)?));
}
before_or_at = self.slot((index as usize + 1) % cardinality as usize);
if !before_or_at.initialized {
before_or_at = self.slot(0);
}
if !lte(time, before_or_at.block_timestamp, target) {
return Err(ObserveError::TooOld);
}
self.binary_search(time, target, index, cardinality)
}
pub fn observe_single(
&self,
time: u32,
seconds_ago: u32,
tick: i32,
index: u16,
liquidity: u128,
cardinality: u16,
) -> Result<(i64, U256), ObserveError> {
if seconds_ago == 0 {
let idx = index as usize;
let Some(mut last) = self.at(idx) else {
return Err(self
.observation_index_err(idx, index, cardinality)
.into());
};
if last.block_timestamp != time {
last = transform(&last, time, tick, liquidity)?;
}
return Ok((last.tick_cumulative, last.seconds_per_liquidity_cumulative_x128));
}
let target = time.wrapping_sub(seconds_ago);
let (before_or_at, at_or_after) =
self.get_surrounding_observations(time, target, tick, index, liquidity, cardinality)?;
if target == before_or_at.block_timestamp {
Ok((before_or_at.tick_cumulative, before_or_at.seconds_per_liquidity_cumulative_x128))
} else if target == at_or_after.block_timestamp {
Ok((at_or_after.tick_cumulative, at_or_after.seconds_per_liquidity_cumulative_x128))
} else {
let observation_time_delta = at_or_after
.block_timestamp
.wrapping_sub(before_or_at.block_timestamp);
let target_delta = target.wrapping_sub(before_or_at.block_timestamp);
let tick_cumulative = before_or_at.tick_cumulative +
(at_or_after.tick_cumulative - before_or_at.tick_cumulative) /
i64::from(observation_time_delta) *
i64::from(target_delta);
let seconds_per_liquidity_cumulative_x128 = {
let delta = safe_sub_u256(
at_or_after.seconds_per_liquidity_cumulative_x128,
before_or_at.seconds_per_liquidity_cumulative_x128,
)?;
let scaled = safe_div_u256(
safe_mul_u256(delta, U256::from(target_delta))?,
U256::from(observation_time_delta),
)?;
safe_add_u256(before_or_at.seconds_per_liquidity_cumulative_x128, scaled)?
};
Ok((tick_cumulative, seconds_per_liquidity_cumulative_x128))
}
}
}
fn lte(time: u32, a: u32, b: u32) -> bool {
if a <= time && b <= time {
return a <= b;
}
let a_adjusted = if a > time { a as u64 } else { a as u64 + (1u64 << 32) };
let b_adjusted = if b > time { b as u64 } else { b as u64 + (1u64 << 32) };
a_adjusted <= b_adjusted
}
fn transform(
before: &Observation,
target: u32,
tick: i32,
liquidity: u128,
) -> Result<Observation, SimulationError> {
let delta = target
.checked_sub(before.block_timestamp)
.ok_or_else(|| {
SimulationError::InvalidInput(
format!(
"Execution timestamp {target} precedes the last observation at {}",
before.block_timestamp
),
None,
)
})?;
let tick_cumulative = before.tick_cumulative + tick as i64 * delta as i64;
let seconds_per_liquidity_cumulative_x128 = if liquidity > 0 {
safe_add_u256(
before.seconds_per_liquidity_cumulative_x128,
(U256::from(delta as u128) << 128) / U256::from(liquidity),
)?
} else {
before.seconds_per_liquidity_cumulative_x128
};
Ok(Observation {
block_timestamp: target,
tick_cumulative,
seconds_per_liquidity_cumulative_x128,
initialized: true,
})
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use hex_literal::hex;
use rstest::rstest;
use super::*;
fn seeded(timestamp: u32) -> Observations {
Observations::new(vec![Observation {
block_timestamp: timestamp,
tick_cumulative: 100,
initialized: true,
..Default::default()
}])
}
#[test]
fn write_is_a_no_op_within_the_same_block() {
let mut observations = seeded(1_000);
let index = observations
.write(0, 1_000, 50, 1_000_000, 4)
.expect("write should succeed");
assert_eq!(index, 0);
assert_eq!(observations.len(), 1);
}
#[test]
fn write_advances_the_ring_and_uses_the_pre_swap_tick() {
let mut observations = seeded(1_000);
let index = observations
.write(0, 1_010, 50, 1_000_000, 4)
.expect("write should succeed");
assert_eq!(index, 1);
let written = observations.slot(1);
assert_eq!(written.block_timestamp, 1_010);
assert_eq!(written.tick_cumulative, 600);
assert!(written.initialized);
}
#[test]
fn write_wraps_at_cardinality() {
let mut observations = Observations::new(vec![
Observation { block_timestamp: 900, initialized: true, ..Default::default() },
Observation { block_timestamp: 950, initialized: true, ..Default::default() },
]);
let index = observations
.write(1, 1_000, 0, 1, 2)
.expect("write should succeed");
assert_eq!(index, 0);
assert_eq!(observations.slot(0).block_timestamp, 1_000);
}
#[test]
fn transform_rejects_a_target_before_the_observation() {
let observations = seeded(1_000);
let err = observations
.observe_single(900, 0, 0, 0, 1, 1)
.expect_err("a target behind the last observation must not wrap");
assert!(
matches!(err, ObserveError::Data(SimulationError::InvalidInput(_, _))),
"got {err:?}"
);
}
#[test]
fn test_lte_basic_cases() {
assert!(lte(100, 90, 95));
assert!(!lte(100, 95, 90));
assert!(lte(100, 100, 100));
}
#[test]
fn test_lte_wrap_around_cases() {
let time = 50;
let a = u32::MAX - 10;
let b = 20;
assert!(lte(time, a, b));
assert!(!lte(time, b, a));
assert!(lte(200, 10, 20));
}
#[test]
fn test_transform_normal_case() {
let before = Observation {
block_timestamp: 100,
tick_cumulative: 10,
seconds_per_liquidity_cumulative_x128: U256::from(0),
initialized: true,
};
let tick = 5;
let liquidity = 10u128;
let target = 110;
let result = transform(&before, target, tick, liquidity).unwrap();
assert_eq!(result.tick_cumulative, 60);
assert_eq!(result.block_timestamp, target);
assert!(result.initialized);
assert!(
result.seconds_per_liquidity_cumulative_x128 >
before.seconds_per_liquidity_cumulative_x128
);
}
#[test]
fn test_transform_zero_liquidity() {
let before = Observation {
block_timestamp: 100,
tick_cumulative: 10,
seconds_per_liquidity_cumulative_x128: U256::from(1234),
initialized: true,
};
let tick = 3;
let liquidity = 0u128;
let target = 110;
let result = transform(&before, target, tick, liquidity).unwrap();
assert_eq!(result.seconds_per_liquidity_cumulative_x128, U256::from(1234));
assert_eq!(result.tick_cumulative, 10 + 3 * 10);
}
#[test]
fn test_transform_large_delta() {
let before = Observation {
block_timestamp: 0,
tick_cumulative: 0,
seconds_per_liquidity_cumulative_x128: U256::from(0),
initialized: true,
};
let result = transform(&before, 100_000, 1, 1000).unwrap();
assert_eq!(result.tick_cumulative, 100_000);
}
fn encode_observation_bytes(
block_timestamp: u32,
tick_cumulative: i64,
seconds_per_liquidity_cumulative_x128: U256,
initialized: bool,
) -> [u8; 32] {
let mut value = U256::from(block_timestamp);
let tick_encoded = if tick_cumulative < 0 {
U256::from((1i128 << 56) + tick_cumulative as i128)
} else {
U256::from(u64::try_from(tick_cumulative).unwrap())
};
value |= tick_encoded << 32u32;
value |= (seconds_per_liquidity_cumulative_x128 & ((U256::from(1) << 160) - U256::from(1))) <<
88u32;
if initialized {
value |= U256::from(1) << 248u32;
}
value.to_be_bytes()
}
#[test]
fn from_attribute_reads_a_word_without_its_leading_zero_bytes() {
let observation = Observation::from_attribute(&[0x01]).expect("short word");
assert_eq!(observation, Observation { block_timestamp: 1, ..Default::default() });
let word = encode_observation_bytes(7, -5, U256::from(9), false);
assert_eq!(word[0], 0, "an uninitialized word starts with a zero byte");
assert_eq!(
Observation::from_attribute(&word[1..]).expect("leading zero dropped"),
Observation::from_attribute(&word).expect("full word")
);
}
#[test]
fn from_attribute_rejects_a_word_longer_than_32_bytes() {
assert!(Observation::from_attribute(&[0; 33]).is_err());
}
#[test]
fn test_from_attribute_and_upsert() {
let bytes = encode_observation_bytes(100, 10, U256::from(123456), true);
let obs = Observation::from_attribute(&bytes).unwrap();
assert_eq!(obs.block_timestamp, 100);
let mut obs_vec = Observations::new(vec![]);
obs_vec
.upsert_observation(0, &bytes)
.unwrap();
assert_eq!(obs_vec.len(), 1);
let bytes2 = encode_observation_bytes(200, 50, U256::from(9999), true);
obs_vec
.upsert_observation(0, &bytes2)
.unwrap();
assert_eq!(obs_vec.slot(0).block_timestamp, 200);
obs_vec
.upsert_observation(0, &[])
.unwrap();
assert_eq!(obs_vec, Observations::new(vec![Observation::default()]));
}
#[test]
fn deleting_a_slot_keeps_later_slots_at_their_index() {
let newest = Observation { block_timestamp: 30, initialized: true, ..Default::default() };
let mut observations = Observations::new(vec![
Observation { block_timestamp: 10, initialized: true, ..Default::default() },
Observation { block_timestamp: 20, initialized: true, ..Default::default() },
newest,
]);
observations
.upsert_observation(1, &[])
.expect("delete");
assert!(!observations.slot(1).initialized);
assert_eq!(observations.slot(2), newest);
}
#[test]
fn uninitialized_slots_past_the_end_are_not_stored() {
let mut observations = Observations::new(vec![Observation {
block_timestamp: 10,
initialized: true,
..Default::default()
}]);
observations
.upsert_observation(500, &[0x01])
.expect("prefilled slot");
observations
.upsert_observation(600, &[])
.expect("deleted slot");
assert_eq!(observations.len(), 1);
assert!(!observations.slot(500).initialized);
}
#[rstest]
#[case::first_slot("observations/0", Some(Ok(0)))]
#[case::last_slot("observations/65534", Some(Ok(65_534)))]
#[case::past_the_ring(
"observations/65535",
Some(Err("observations/65535: slot 65535 is past the 65535-slot ring".to_string()))
)]
#[case::past_u16("observations/65536", Some(Err("observations/65536: number too large to fit in target type".to_string())))]
#[case::not_a_number("observations/next", Some(Err("observations/next: invalid digit found in string".to_string())))]
#[case::other_attribute("tick", None)]
fn observation_slot_accepts_only_the_rings_slots(
#[case] key: &str,
#[case] expected: Option<Result<u16, String>>,
) {
assert_eq!(observation_slot(key), expected);
}
#[test]
fn prefilled_word_inside_the_ring_is_stored_like_an_unwritten_slot() {
let written = encode_observation_bytes(10, 0, U256::ZERO, true);
let mut observations =
Observations::from_words([(0, written.as_slice()), (2, &written)]).expect("ring");
let snapshot = observations.clone();
observations
.upsert_observation(1, &[0x01])
.expect("prefilled slot");
assert_eq!(observations, snapshot);
}
#[test]
fn ring_rebuilt_from_stream_words_observes_like_the_chain() {
let mut observations = Observations::new(Vec::new());
let written = [
(1_789_205_466, -3_753_782_792, "4871078707023353428616415205"),
(1_789_206_050, -3_869_381_504, "4943578347386704671325331035"),
(1_789_206_560, -3_970_336_004, "5006891389484836749718391092"),
];
for (index, (timestamp, tick_cumulative, seconds_per_liquidity)) in (0..).zip(written) {
let word = encode_observation_bytes(
timestamp,
tick_cumulative,
U256::from_str(seconds_per_liquidity).expect("decimal cumulative"),
true,
);
observations
.upsert_observation(index, &word)
.expect("written slot");
}
for index in 3..500 {
observations
.upsert_observation(index, &[0x01])
.expect("prefilled slot");
}
let (tick_cumulatives, seconds_per_liquidity_cumulatives) = observations
.observe(1_789_206_560, &[600, 0], -197_954, 2, 2_741_046_731_899_156, 500)
.expect("the chain answers this window");
assert_eq!(tick_cumulatives, vec![-3_851_566_634, -3_970_336_004]);
assert_eq!(
seconds_per_liquidity_cumulatives,
vec![
U256::from_str("4932405457604681363373614554").expect("decimal cumulative"),
U256::from_str("5006891389484836749718391092").expect("decimal cumulative"),
]
);
}
#[test]
fn window_reaching_before_time_zero_wraps_and_reverts_old() {
let observations = Observations::new(vec![Observation {
block_timestamp: 50,
initialized: true,
..Default::default()
}]);
let result = observations.observe(100, &[600, 0], 0, 0, 1, 1);
assert!(matches!(result, Err(ObserveError::TooOld)), "got {result:?}");
}
#[test]
fn test_observe_single() {
let bytes = encode_observation_bytes(
1762309495,
-16009850,
U256::from_str("2566142326090727851500728328109973377").unwrap(),
true,
);
let mut obs = Observations::new(vec![]);
assert!(obs
.upsert_observation(216, &bytes)
.is_ok());
assert_eq!(
obs.observe(1762330020, &[600, 0], 0, 216, 85863056191940832, 360)
.unwrap(),
(
vec![-16009850, -16009850],
vec![
U256::from_str("2566142326169692268347750439884046480").unwrap(),
U256::from_str("2566142326172070117788564154667707401").unwrap()
]
)
);
}
#[test]
fn test_observe_multiple() {
let items: &[(u16, [u8; 32])] = &[
(534, hex!("01000006a0000001485073e3b9c1b1ba599e933717fff778eb3ff056690b05a1")),
(535, hex!("01000006a0000001485072f3c785d8212da7414577fff77952e1b5ec690ae2d7")),
(2039, hex!("01000006a00000014850737217b73678a71c3a98fdfff7791d60d77e690af4cd")),
(2040, hex!("01000006a00000014850737239d75dce70d02120fffff7791d5ae25e690af4cf")),
(2792, hex!("01000006a0000001485073a83aca03f518567293a7fff779047fd580690afd27")),
(2793, hex!("01000006a0000001485073a84425ed86707cf3426afff7790473eae0690afd2b")),
(158, hex!("01000006a0000001485073c3bd34f1a8b1e3595ef2fff778f7fab090690b015b")),
(159, hex!("01000006a0000001485073c3bfcaf719d5a10d1babfff778f7f4bb8c690b015d")),
(346, hex!("01000006a0000001485073d0992e1120d6162dec08fff778f1d01820690b036d")),
(347, hex!("01000006a0000001485073d0a6e39cdb5daeb0b3dcfff778f1be390e690b0373")),
(252, hex!("01000006a0000001485073ca9b84bedd861255f8f6fff778f4ca8f18690b026d")),
(253, hex!("01000006a0000001485073caa9f9acbba60b0ac592fff778f4c49a22690b026f")),
(299, hex!("01000006a0000001485073cc668d277afc9908bf5afff778f35f3120690b02e7")),
(300, hex!("01000006a0000001485073cc6cec51a251dcd597a7fff778f3593c34690b02e9")),
(322, hex!("01000006a0000001485073ce6eb2883c6b9c109292fff778f2a688ec690b0325")),
(323, hex!("01000006a0000001485073ce7c9a63260beda5874ffff778f2a09414690b0327")),
(334, hex!("01000006a0000001485073cf5c7f6da6dee6f54694fff778f21d8926690b0353")),
(335, hex!("01000006a0000001485073cf7b9869740c05f0bf44fff778f2179430690b0355")),
(328, hex!("01000006a0000001485073cecedc4b2732bd3fb882fff778f24d3044690b0343")),
(329, hex!("01000006a0000001485073ced7e92fc61bfda7ccd4fff778f2414694690b0347")),
(331, hex!("01000006a0000001485073cee01b7e722a6b0763d3fff778f2355ce2690b034b")),
(332, hex!("01000006a0000001485073ceff347a3f578a02dc83fff778f22f67f6690b034d")),
];
let mut obs = Observations::new(vec![]);
for (idx, bytes) in items.iter().copied() {
assert!(obs
.upsert_observation(idx, &bytes)
.is_ok());
}
assert_eq!(
obs.observe(1762330020, &[600, 0], -195239, 534, 1102101691356476042, 3010)
.unwrap(),
(
vec![-9376145186196, -9376262324127],
vec![
U256::from_str("577118894323923370143045372175062197936171").unwrap(),
U256::from_str("577118894323923370242147069684646219844755").unwrap()
]
)
);
}
}