blockworks-foundation
/
autobahn
mirror of https://github.com/blockworks-foundation/autobahn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove panic from tick_to_position

This commit is contained in:
none00y 2024-11-09 18:37:57 +01:00
parent 76b91ade47
commit e692dba055
2 changed files with 150 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/dex-invariant/src/internal/invariant-types/src/math.rs
View File

@ -97,13 +97,13 @@ pub fn get_closer_limit(
current_tick: i32, // tick already scaled by tick_spacing current_tick: i32, // tick already scaled by tick_spacing
tick_spacing: u16, tick_spacing: u16,
tickmap: &TickmapView, tickmap: &TickmapView,
) -> Result<(Price, Option<(i32, bool)>)> { ) -> TrackableResult<(Price, Option<(i32, bool)>)> {
// find initalized tick (None also for virtual tick limiated by search scope) // find initalized tick (None also for virtual tick limiated by search scope)
let closes_tick_index = if x_to_y { let closes_tick_index = if x_to_y {
tickmap.prev_initialized(current_tick, tick_spacing) tickmap.prev_initialized(current_tick, tick_spacing)
} else { } else {
tickmap.next_initialized(current_tick, tick_spacing) tickmap.next_initialized(current_tick, tick_spacing)
}; }?;
match closes_tick_index { match closes_tick_index {
Some(index) => { Some(index) => {
@ -121,7 +121,9 @@ pub fn get_closer_limit(
let index = get_search_limit(current_tick, tick_spacing, !x_to_y); let index = get_search_limit(current_tick, tick_spacing, !x_to_y);
let price = calculate_price_sqrt(index); let price = calculate_price_sqrt(index);
require!(current_tick != index, InvariantErrorCode::LimitReached); if current_tick == index {
return Err(err!("InvariantErrorCode::LimitReached"));
}
// trunk-ignore(clippy/if_same_then_else) // trunk-ignore(clippy/if_same_then_else)
if x_to_y && price > sqrt_price_limit { if x_to_y && price > sqrt_price_limit {

255
lib/dex-invariant/src/internal/invariant-types/src/structs/tickmap.rs
View File

@ -4,7 +4,7 @@ use crate::{size, MAX_VIRTUAL_CROSS};
use anchor_lang::prelude::*; use anchor_lang::prelude::*;
use crate::utils::{TrackableError, TrackableResult}; use crate::utils::{TrackableError, TrackableResult};
use crate::{err, function, location, trace}; use crate::{err, function, location};
pub const TICK_LIMIT: i32 = 44_364; // If you change it update length of array as well! pub const TICK_LIMIT: i32 = 44_364; // If you change it update length of array as well!
pub const TICK_SEARCH_RANGE: i32 = 256; pub const TICK_SEARCH_RANGE: i32 = 256;
@ -17,23 +17,34 @@ const TICKMAP_RANGE: usize = (TICK_CROSSES_PER_IX + TICKS_BACK_COUNT + MAX_VIRTU
* TICK_SEARCH_RANGE as usize; * TICK_SEARCH_RANGE as usize;
const TICKMAP_SLICE_SIZE: usize = TICKMAP_RANGE / 8 + 2; const TICKMAP_SLICE_SIZE: usize = TICKMAP_RANGE / 8 + 2;
pub fn tick_to_position(tick: i32, tick_spacing: u16) -> (usize, u8) { pub fn tick_to_position(tick: i32, tick_spacing: u16) -> TrackableResult<(usize, u8)> {
assert_eq!( if (tick
(tick % tick_spacing as i32), .checked_rem_euclid(tick_spacing as i32)
0, .ok_or(err!("tick spacing is zero"))?)
"tick not divisible by spacing" != 0
); {
return Err(err!("tick not divisible by spacing"));
}
let bitmap_index = tick let bitmap_index = tick
.checked_div(tick_spacing.try_into().unwrap()) .checked_div(
.unwrap() tick_spacing
.try_into()
.map_err(|_| err!("failed to convert tick spacing"))?,
)
.ok_or(err!("sub underflow"))?
.checked_add(TICK_LIMIT) .checked_add(TICK_LIMIT)
.unwrap(); .ok_or(err!("add overflow"))?;
let byte: usize = (bitmap_index.checked_div(8).unwrap()).try_into().unwrap(); let byte: usize = (bitmap_index.checked_div(8).unwrap())
let bit: u8 = (bitmap_index % 8).abs().try_into().unwrap(); .try_into()
.map_err(|_| err!("failed to convert bitmap byte"))?;
let bit: u8 = (bitmap_index % 8)
.abs()
.try_into()
.map_err(|_| (err!("failed to convert bitmap bit")))?;
(byte, bit) Ok((byte, bit))
} }
// tick_spacing - spacing already scaled by tick_spacing // tick_spacing - spacing already scaled by tick_spacing
@ -86,22 +97,24 @@ impl Debug for Tickmap {
size!(Tickmap); size!(Tickmap);
impl Tickmap { impl Tickmap {
pub fn get(&self, tick: i32, tick_spacing: u16) -> bool { pub fn get(&self, tick: i32, tick_spacing: u16) -> TrackableResult<bool> {
let (byte, bit) = tick_to_position(tick, tick_spacing); let (byte, bit) = tick_to_position(tick, tick_spacing)?;
let value = (self.bitmap[byte] >> bit) % 2; let value = (self.bitmap[byte] >> bit) % 2;
(value) == 1 Ok((value) == 1)
} }
pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) { pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) -> TrackableResult<()> {
assert!( assert!(
self.get(tick, tick_spacing) != value, self.get(tick, tick_spacing)? != value,
"tick initialize tick again" "tick initialize tick again"
); );
let (byte, bit) = tick_to_position(tick, tick_spacing); let (byte, bit) = tick_to_position(tick, tick_spacing)?;
self.bitmap[byte] ^= 1 << bit; self.bitmap[byte] ^= 1 << bit;
Ok(())
} }
} }
pub struct TickmapSlice { pub struct TickmapSlice {
@ -118,15 +131,19 @@ impl Default for TickmapSlice {
} }
impl TickmapSlice { impl TickmapSlice {
pub fn calculate_search_range_offset(init_tick: i32, spacing: u16, up: bool) -> i32 { pub fn calculate_search_range_offset(
init_tick: i32,
spacing: u16,
up: bool,
) -> TrackableResult<i32> {
let search_limit = get_search_limit(init_tick, spacing, up); let search_limit = get_search_limit(init_tick, spacing, up);
let position = tick_to_position(search_limit, spacing).0 as i32; let position = tick_to_position(search_limit, spacing)?.0 as i32;
if up { Ok(if up {
position - TICKMAP_SLICE_SIZE as i32 + 1 position - TICKMAP_SLICE_SIZE as i32 + 1
} else { } else {
position position
} })
} }
pub fn from_slice( pub fn from_slice(
@ -201,17 +218,17 @@ impl std::fmt::Debug for TickmapView {
} }
impl TickmapView { impl TickmapView {
pub fn next_initialized(&self, tick: i32, tick_spacing: u16) -> Option<i32> { pub fn next_initialized(&self, tick: i32, tick_spacing: u16) -> TrackableResult<Option<i32>> {
let limit = get_search_limit(tick, tick_spacing, true); let limit = get_search_limit(tick, tick_spacing, true);
// add 1 to not check current tick // add 1 to not check current tick
let (mut byte, mut bit) = let (mut byte, mut bit) =
tick_to_position(tick.checked_add(tick_spacing as i32).unwrap(), tick_spacing); tick_to_position(tick.checked_add(tick_spacing as i32).unwrap(), tick_spacing)?;
let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing)?;
while byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) { while byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) {
// ignore some bits on first loop // ignore some bits on first loop
let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing)?;
let mut shifted = self.bitmap[byte] >> bit; let mut shifted = self.bitmap[byte] >> bit;
// go through all bits in byte until it is zero // go through all bits in byte until it is zero
@ -221,44 +238,46 @@ impl TickmapView {
bit = bit.checked_add(1).unwrap(); bit = bit.checked_add(1).unwrap();
} }
return if byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) { return Ok(
let index: i32 = byte if byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) {
.checked_mul(8) let index: i32 = byte
.unwrap() .checked_mul(8)
.checked_add(bit.into())
.unwrap()
.try_into()
.unwrap();
Some(
index
.checked_sub(TICK_LIMIT)
.unwrap() .unwrap()
.checked_mul(tick_spacing.try_into().unwrap()) .checked_add(bit.into())
.unwrap(), .unwrap()
) .try_into()
} else { .unwrap();
None Some(
}; index
.checked_sub(TICK_LIMIT)
.unwrap()
.checked_mul(tick_spacing.try_into().unwrap())
.unwrap(),
)
} else {
None
},
);
} }
// go to the text byte // go to the text byte
if let Some(value) = byte.checked_add(1) { if let Some(value) = byte.checked_add(1) {
byte = value; byte = value;
} else { } else {
return None; return Ok(None);
} }
bit = 0; bit = 0;
} }
None Ok(None)
} }
// tick_spacing - spacing already scaled by tick_spacing // tick_spacing - spacing already scaled by tick_spacing
pub fn prev_initialized(&self, tick: i32, tick_spacing: u16) -> Option<i32> { pub fn prev_initialized(&self, tick: i32, tick_spacing: u16) -> TrackableResult<Option<i32>> {
// don't subtract 1 to check the current tick // don't subtract 1 to check the current tick
let limit = get_search_limit(tick, tick_spacing, false); // limit scaled by tick_spacing let limit = get_search_limit(tick, tick_spacing, false); // limit scaled by tick_spacing
let (mut byte, mut bit) = tick_to_position(tick as i32, tick_spacing); let (mut byte, mut bit) = tick_to_position(tick as i32, tick_spacing)?;
let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing)?;
while byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) { while byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) {
// always safe due to limitated domain of bit variable // always safe due to limitated domain of bit variable
@ -274,56 +293,60 @@ impl TickmapView {
} }
// return first initalized tick if limiit is not exceeded, otherswise return None // return first initalized tick if limiit is not exceeded, otherswise return None
return if byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) { return Ok(
// no possibility to overflow if byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) {
let index: i32 = byte // no possibility to overflow
.checked_mul(8) let index: i32 = byte
.unwrap() .checked_mul(8)
.checked_add(bit.into())
.unwrap()
.try_into()
.unwrap();
Some(
index
.checked_sub(TICK_LIMIT)
.unwrap() .unwrap()
.checked_mul(tick_spacing.try_into().unwrap()) .checked_add(bit.into())
.unwrap(), .unwrap()
) .try_into()
} else { .unwrap();
None
}; Some(
index
.checked_sub(TICK_LIMIT)
.unwrap()
.checked_mul(tick_spacing.try_into().unwrap())
.unwrap(),
)
} else {
None
},
);
} }
// go to the next byte // go to the next byte
if let Some(value) = byte.checked_sub(1) { if let Some(value) = byte.checked_sub(1) {
byte = value; byte = value;
} else { } else {
return None; return Ok(None);
} }
bit = 7; bit = 7;
} }
None Ok(None)
} }
pub fn get(&self, tick: i32, tick_spacing: u16) -> bool { pub fn get(&self, tick: i32, tick_spacing: u16) -> TrackableResult<bool> {
let (byte, bit) = tick_to_position(tick, tick_spacing); let (byte, bit) = tick_to_position(tick, tick_spacing)?;
let value = (self.bitmap[byte] >> bit) % 2; let value = (self.bitmap[byte] >> bit) % 2;
(value) == 1 Ok((value) == 1)
} }
pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) { pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) -> TrackableResult<()> {
assert!( assert!(
self.get(tick, tick_spacing) != value, self.get(tick, tick_spacing)? != value,
"tick initialize tick again" "tick initialize tick again"
); );
let (byte, bit) = tick_to_position(tick, tick_spacing); let (byte, bit) = tick_to_position(tick, tick_spacing)?;
self.bitmap[byte] ^= 1 << bit; self.bitmap[byte] ^= 1 << bit;
Ok(())
} }
pub fn from_slice( pub fn from_slice(
@ -356,9 +379,11 @@ mod tests {
println!("max_index = {}", max_index); println!("max_index = {}", max_index);
println!("min_index = {}", min_index); println!("min_index = {}", min_index);
let offset_high = let offset_high =
TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true); TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true)
.unwrap();
let offset_low = let offset_low =
TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false); TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false)
.unwrap();
let mut map_low = TickmapView { let mut map_low = TickmapView {
bitmap: TickmapSlice { bitmap: TickmapSlice {
@ -372,13 +397,17 @@ mod tests {
..Default::default() ..Default::default()
}, },
}; };
map_low.flip(true, min_index, spacing as u16); map_low.flip(true, min_index, spacing as u16).unwrap();
map_high.flip(true, max_index, spacing as u16); map_high.flip(true, max_index, spacing as u16).unwrap();
let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing; let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing;
let prev = map_low.prev_initialized(min_index + tick_edge_diff, spacing as u16); let prev = map_low
let next = map_high.next_initialized(max_index - tick_edge_diff, spacing as u16); .prev_initialized(min_index + tick_edge_diff, spacing as u16)
.unwrap();
let next = map_high
.next_initialized(max_index - tick_edge_diff, spacing as u16)
.unwrap();
if prev.is_some() { if prev.is_some() {
println!("found prev = {}", prev.unwrap()); println!("found prev = {}", prev.unwrap());
@ -399,9 +428,11 @@ mod tests {
let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing; let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing;
let offset_high = let offset_high =
TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true); TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true)
.unwrap();
let offset_low = let offset_low =
TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false); TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false)
.unwrap();
let map_low = TickmapView { let map_low = TickmapView {
bitmap: TickmapSlice { bitmap: TickmapSlice {
offset: offset_low, offset: offset_low,
@ -415,8 +446,12 @@ mod tests {
}, },
}; };
let prev = map_low.prev_initialized(min_index + tick_edge_diff, spacing as u16); let prev = map_low
let next = map_high.next_initialized(max_index - tick_edge_diff, spacing as u16); .prev_initialized(min_index + tick_edge_diff, spacing as u16)
.unwrap();
let next = map_high
.next_initialized(max_index - tick_edge_diff, spacing as u16)
.unwrap();
if prev.is_some() { if prev.is_some() {
println!("found prev = {}", prev.unwrap()); println!("found prev = {}", prev.unwrap());
@ -437,10 +472,10 @@ mod tests {
let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; let low_tick = low_byte * 8 + low_bit - TICK_LIMIT;
let high_tick = low_tick + TICKMAP_RANGE as i32; let high_tick = low_tick + TICKMAP_RANGE as i32;
let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); let (high_byte, _high_bit) = tick_to_position(high_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = let tickmap_x_to_y =
TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap(); TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap();
let tickmap_y_to_x = let tickmap_y_to_x =
@ -470,10 +505,10 @@ mod tests {
let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; let low_tick = low_byte * 8 + low_bit - TICK_LIMIT;
let high_tick = low_tick + TICKMAP_RANGE as i32; let high_tick = low_tick + TICKMAP_RANGE as i32;
let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); let (high_byte, _high_bit) = tick_to_position(high_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = let tickmap_x_to_y =
TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap(); TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap();
let tickmap_y_to_x = let tickmap_y_to_x =
@ -503,10 +538,10 @@ mod tests {
let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; let high_tick = high_byte * 8 + high_bit - TICK_LIMIT;
let low_tick = high_tick - TICKMAP_RANGE as i32; let low_tick = high_tick - TICKMAP_RANGE as i32;
let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); let (low_byte, _low_bit) = tick_to_position(low_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = let tickmap_x_to_y =
TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap(); TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap();
let tickmap_y_to_x = let tickmap_y_to_x =
@ -536,10 +571,10 @@ mod tests {
let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; let high_tick = high_byte * 8 + high_bit - TICK_LIMIT;
let low_tick = high_tick - TICKMAP_RANGE as i32; let low_tick = high_tick - TICKMAP_RANGE as i32;
let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); let (low_byte, _low_bit) = tick_to_position(low_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = let tickmap_x_to_y =
TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap(); TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap();
let tickmap_y_to_x = let tickmap_y_to_x =
@ -577,10 +612,10 @@ mod tests {
let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; let low_tick = low_byte * 8 + low_bit - TICK_LIMIT;
let high_tick = low_tick + TICKMAP_RANGE as i32; let high_tick = low_tick + TICKMAP_RANGE as i32;
let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); let (high_byte, _high_bit) = tick_to_position(high_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = TickmapSlice::from_slice( let tickmap_x_to_y = TickmapSlice::from_slice(
&tickmap.bitmap, &tickmap.bitmap,
low_tick + range_offset_with_tick_back, low_tick + range_offset_with_tick_back,
@ -605,10 +640,10 @@ mod tests {
let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; let low_tick = low_byte * 8 + low_bit - TICK_LIMIT;
let high_tick = low_tick + TICKMAP_RANGE as i32; let high_tick = low_tick + TICKMAP_RANGE as i32;
let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); let (high_byte, _high_bit) = tick_to_position(high_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_x_to_y = TickmapSlice::from_slice( let tickmap_x_to_y = TickmapSlice::from_slice(
&tickmap.bitmap, &tickmap.bitmap,
low_tick + range_offset_with_tick_back, low_tick + range_offset_with_tick_back,
@ -633,10 +668,10 @@ mod tests {
let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; let high_tick = high_byte * 8 + high_bit - TICK_LIMIT;
let low_tick = high_tick - TICKMAP_RANGE as i32; let low_tick = high_tick - TICKMAP_RANGE as i32;
let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); let (low_byte, _low_bit) = tick_to_position(low_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_y_to_x = TickmapSlice::from_slice( let tickmap_y_to_x = TickmapSlice::from_slice(
&tickmap.bitmap, &tickmap.bitmap,
high_tick - range_offset_with_tick_back, high_tick - range_offset_with_tick_back,
@ -661,10 +696,10 @@ mod tests {
let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; let high_tick = high_byte * 8 + high_bit - TICK_LIMIT;
let low_tick = high_tick - TICKMAP_RANGE as i32; let low_tick = high_tick - TICKMAP_RANGE as i32;
let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); let (low_byte, _low_bit) = tick_to_position(low_tick, spacing).unwrap();
tickmap.flip(true, low_tick, spacing); tickmap.flip(true, low_tick, spacing).unwrap();
tickmap.flip(true, high_tick, spacing); tickmap.flip(true, high_tick, spacing).unwrap();
let tickmap_y_to_x = TickmapSlice::from_slice( let tickmap_y_to_x = TickmapSlice::from_slice(
&tickmap.bitmap, &tickmap.bitmap,
high_tick - range_offset_with_tick_back, high_tick - range_offset_with_tick_back,