use starknet::core::types::Felt;
pub fn felt_to_u64(felt: &Felt) -> u64 {
let bytes = felt.to_bytes_be();
u64::from_be_bytes(bytes[24..32].try_into().unwrap_or([0u8; 8]))
}
pub fn felt_to_usize_checked(felt: &Felt) -> Option<usize> {
let bytes = felt.to_bytes_be();
if bytes[..24].iter().any(|&b| b != 0) {
return None;
}
let value = u64::from_be_bytes(bytes[24..32].try_into().ok()?);
usize::try_from(value).ok()
}
pub fn felt_to_u128(felt: &Felt) -> u128 {
let bytes = felt.to_bytes_be();
u128::from_be_bytes(bytes[16..32].try_into().unwrap_or([0u8; 16]))
}
pub fn merge_block_interval(ranges: &mut Vec<(u64, u64)>, lo: u64, hi: u64) {
let (lo, hi) = if lo <= hi { (lo, hi) } else { (hi, lo) };
let mut merged = (lo, hi);
let mut rest = Vec::with_capacity(ranges.len() + 1);
for &(rlo, rhi) in ranges.iter() {
if rlo <= merged.1.saturating_add(1) && merged.0.saturating_sub(1) <= rhi {
merged = (merged.0.min(rlo), merged.1.max(rhi));
} else {
rest.push((rlo, rhi));
}
}
rest.push(merged);
rest.sort_unstable();
*ranges = rest;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_felt_to_usize_checked_accepts_small_values() {
assert_eq!(felt_to_usize_checked(&Felt::from(0u64)), Some(0));
assert_eq!(felt_to_usize_checked(&Felt::from(42u64)), Some(42));
assert_eq!(
felt_to_usize_checked(&Felt::from_hex("0xFFFFFFFFFFFFFFFF").unwrap()),
usize::try_from(u64::MAX).ok()
);
}
#[test]
fn test_felt_to_usize_checked_rejects_oversized_felts() {
let wraps = Felt::from_hex("0x10000000000000003").unwrap();
assert_eq!(felt_to_u64(&wraps), 3, "low-64 conversion truncates");
assert_eq!(
felt_to_usize_checked(&wraps),
None,
"checked conversion rejects"
);
let addr =
Felt::from_hex("0x700000000000000000000000000000000000000000000000000000000000000")
.unwrap();
assert_eq!(felt_to_u64(&addr), 0, "low-64 conversion truncates to zero");
assert_eq!(felt_to_usize_checked(&addr), None);
}
}