From d5f807a0f48051b19c99e54c97e2e0000ad72daf Mon Sep 17 00:00:00 2001 From: aritkulova Date: Mon, 10 Aug 2026 20:06:29 +0300 Subject: [PATCH 1/4] added convert functions for u64 --- simf/lib/u64/convert.simf | 67 ++++++ simf/lib/{u64.simf => u64/math.simf} | 5 - simf/u64_convert_test.simf | 116 ++++++++++ simf/{u64_test.simf => u64_math_test.simf} | 22 +- tests/u64_convert_test.rs | 243 +++++++++++++++++++++ tests/u64_math_test.rs | 40 ++++ tests/u64_test.rs | 75 ------- 7 files changed, 478 insertions(+), 90 deletions(-) create mode 100644 simf/lib/u64/convert.simf rename simf/lib/{u64.simf => u64/math.simf} (94%) create mode 100644 simf/u64_convert_test.simf rename simf/{u64_test.simf => u64_math_test.simf} (85%) create mode 100644 tests/u64_convert_test.rs create mode 100644 tests/u64_math_test.rs delete mode 100644 tests/u64_test.rs diff --git a/simf/lib/u64/convert.simf b/simf/lib/u64/convert.simf new file mode 100644 index 0000000..b51a592 --- /dev/null +++ b/simf/lib/u64/convert.simf @@ -0,0 +1,67 @@ +/// Widening uint conversions + +/// Converts u64 to u128 +pub fn u64_to_u128(a: u64) -> u128 { + <(u64, u64)>::into((0, a)) +} + +/// Converts u64 to u256 +pub fn u64_to_u256(a: u64) -> u256 { + let a_u128: u128 = u64_to_u128(a); + + <(u128, u128)>::into((0, a_u128)) +} + +/// Splitting uint conversions + +/// Splits u64 into four u16 +pub fn split_u64_to_u16(a: u64) -> (u16, u16, u16, u16) { + ::into(a) +} + +/// Splits u64 into two u32 +pub fn split_u64_to_u32(a: u64) -> (u32, u32) { + ::into(a) +} + +/// Narrowing uint conversions + +/// Converts u64 into u1. +/// Panics if the value does not fit in u1 +pub fn safe_u64_to_u1(a: u64) -> u1 { + let u1_max: u64 = jet::left_pad_low_1_64(jet::high_1()); + + assert!(jet::le_64(a, u1_max)); + + jet::rightmost_64_1(a) +} + +/// Converts u64 into u8. +/// Panics if the value does not fit in u8 +pub fn safe_u64_to_u8(a: u64) -> u8 { + let u8_max: u64 = jet::left_pad_low_8_64(jet::high_8()); + + assert!(jet::le_64(a, u8_max)); + + jet::rightmost_64_8(a) +} + +/// Converts u64 into u16. +/// Panics if the value does not fit in u16 +pub fn safe_u64_to_u16(a: u64) -> u16 { + let u16_max: u64 = jet::left_pad_low_16_64(jet::high_16()); + + assert!(jet::le_64(a, u16_max)); + + jet::rightmost_64_16(a) +} + +/// Converts u64 into u32. +/// Panics if the value does not fit in u32 +pub fn safe_u64_to_u32(a: u64) -> u32 { + let u32_max: u64 = jet::left_pad_low_32_64(jet::high_32()); + + assert!(jet::le_64(a, u32_max)); + + jet::rightmost_64_32(a) +} diff --git a/simf/lib/u64.simf b/simf/lib/u64/math.simf similarity index 94% rename from simf/lib/u64.simf rename to simf/lib/u64/math.simf index f3fd3da..77fc4aa 100644 --- a/simf/lib/u64.simf +++ b/simf/lib/u64/math.simf @@ -67,8 +67,3 @@ pub fn gt_64(a: u64, b: u64) -> bool { pub fn ge_64(a: u64, b: u64) -> bool { jet::le_64(b, a) } - -/// Widen `u64` to a `u256` scalar. -pub fn u64_into_u256(val: u64) -> u256 { - <(u64, u64, u64, u64)>::into((0, 0, 0, val)) -} diff --git a/simf/u64_convert_test.simf b/simf/u64_convert_test.simf new file mode 100644 index 0000000..b706f55 --- /dev/null +++ b/simf/u64_convert_test.simf @@ -0,0 +1,116 @@ +use crate::lib::u64::convert::{ + u64_to_u128, + u64_to_u256, + split_u64_to_u16, + split_u64_to_u32, + safe_u64_to_u1, + safe_u64_to_u8, + safe_u64_to_u16, + safe_u64_to_u32 +}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_128, + assert_eq_256 +}; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u64 = witness::FIRST_ARG; + + let expected: u256 = witness::EXPECTED; + + match if_test_this_function(0, fn_idx) { + true => { + let (_, expected): (u128, u128) = ::into(expected); + + assert_eq_128(u64_to_u128(a), expected); + }, + false => {}, + }; + + match if_test_this_function(1, fn_idx) { + true => { + assert_eq_256(u64_to_u256(a), expected); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_to_u16(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u16, u16, u16, u16) = ::into(expected); + + assert_eq_16(a3, expected3); + assert_eq_16(a2, expected2); + assert_eq_16(a1, expected1); + assert_eq_16(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (a1, a0): (u32, u32) = split_u64_to_u32(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (expected1, expected0): (u32, u32) = ::into(expected); + + assert_eq_32(a1, expected1); + assert_eq_32(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u1 = jet::rightmost_64_1(expected); + + assert_eq_1(safe_u64_to_u1(a), expected); + }, + false => {}, + }; + + match if_test_this_function(5, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u8 = jet::rightmost_64_8(expected); + + assert_eq_8(safe_u64_to_u8(a), expected); + }, + false => {}, + }; + + match if_test_this_function(6, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u16 = jet::rightmost_64_16(expected); + + assert_eq_16(safe_u64_to_u16(a), expected); + }, + false => {}, + }; + + match if_test_this_function(7, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u32 = jet::rightmost_64_32(expected); + + assert_eq_32(safe_u64_to_u32(a), expected); + }, + false => {}, + }; +} diff --git a/simf/u64_test.simf b/simf/u64_math_test.simf similarity index 85% rename from simf/u64_test.simf rename to simf/u64_math_test.simf index 879215f..0866a57 100644 --- a/simf/u64_test.simf +++ b/simf/u64_math_test.simf @@ -1,6 +1,14 @@ -use crate::lib::u64::{ - checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64, - gt_64, ge_64, u64_into_u256, +use crate::lib::u64::math::{ + checked_add_64, + safe_add_64, + checked_sub_64, + safe_sub_64, + checked_mul_64, + safe_mul_64, + checked_div_64, + safe_div_64, + gt_64, + ge_64 }; use crate::lib::asserts::{assert_none_64, assert_eq_64}; use crate::lib::binary::not; @@ -11,8 +19,8 @@ use crate::helper::if_test_this_function; /// witness value carries both, removing the need for a separate overflow flag. fn assert_eq_opt(result: Option, expected: Option) { match expected { - None => assert_none_64(result), Some(e: u64) => assert_eq_64(unwrap(result), e), + None => assert_none_64(result), } } @@ -32,9 +40,6 @@ fn main() { let b: u64 = witness::SECOND_ARG; let expected: Option = witness::EXPECTED; - let expected_widen: u256 = witness::EXPECTED_WIDEN; - - // add match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_64(a, b), expected); }, false => (), }; match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_64(safe_add_64(a, b), unwrap(expected))); }, false => (), }; @@ -54,7 +59,4 @@ fn main() { // gt, ge match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_64(a, b), expected); }, false => (), }; match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_64(a, b), expected); }, false => (), }; - - // Custom - match if_test_this_function(192, fn_idx) { true => { assert!(jet::eq_256(u64_into_u256(a), expected_widen)); }, false => (), }; } diff --git a/tests/u64_convert_test.rs b/tests/u64_convert_test.rs new file mode 100644 index 0000000..d88fdaf --- /dev/null +++ b/tests/u64_convert_test.rs @@ -0,0 +1,243 @@ +mod common; + +use primitive_types::U256; +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u64_convert_test::U64ConvertTestProgram; +use simplicityhl_std::artifacts::u64_convert_test::derived_u64_convert_test::{ + U64ConvertTestArguments, U64ConvertTestWitness, +}; + +enum FunctionToTest { + U64ToU128, + U64ToU256, + SplitU64ToU16, + SplitU64ToU32, + SafeU64ToU1, + SafeU64ToU8, + SafeU64ToU16, + SafeU64ToU32, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U64ConvertTestProgram { + U64ConvertTestProgram::new(U64ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: u64, expected: [u8; 32]) -> U64ConvertTestWitness { + U64ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u64_convert_test { + use super::*; + + #[simplex::test] + fn u64_convert_test_u64_to_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U64ToU128), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_u64_to_u256(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U64ToU256), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_split_u64_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_split_u64_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u1_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(2..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u8_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u8::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u16::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u16_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u16::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u32::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u32_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u32::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } +} diff --git a/tests/u64_math_test.rs b/tests/u64_math_test.rs new file mode 100644 index 0000000..91214e6 --- /dev/null +++ b/tests/u64_math_test.rs @@ -0,0 +1,40 @@ +mod common; + +use common::uint::TestUint; + +use simplicityhl_std::artifacts::u64_math_test::U64MathTestProgram; +use simplicityhl_std::artifacts::u64_math_test::derived_u64_math_test::{ + U64MathTestArguments, U64MathTestWitness, +}; + +// The only per-width code for the common operations. +impl TestUint for u64 { + type Program = U64MathTestProgram; + type Witness = U64MathTestWitness; + + const ZERO: u64 = 0; + const ONE: u64 = 1; + const MAX: u64 = u64::MAX; + const HALF_MAX: u64 = u64::MAX / 2; + const MUL_BOUND: u64 = 1 << 32; // 2^(64/2) + + fn program() -> U64MathTestProgram { + U64MathTestProgram::new(U64MathTestArguments {}) + } + + fn witness(op: u8, a: u64, b: u64, expected: Option) -> U64MathTestWitness { + U64MathTestWitness { + function_index: op, + first_arg: a, + second_arg: b, + expected, + } + } +} + +mod u64_math_tests { + use super::*; + + // Stamps the 22 `#[simplex::test]` entry points for u64. Logic lives in common::uint. + uint_tests!(u64); +} diff --git a/tests/u64_test.rs b/tests/u64_test.rs deleted file mode 100644 index 59cbed8..0000000 --- a/tests/u64_test.rs +++ /dev/null @@ -1,75 +0,0 @@ -mod common; - -use common::uint::TestUint; - -use simplicityhl_std::artifacts::u64_test::U64TestProgram; -use simplicityhl_std::artifacts::u64_test::derived_u64_test::{U64TestArguments, U64TestWitness}; - -use crate::common::uint::CUSTOM_BASE; - -// The only per-width code for the common operations. -impl TestUint for u64 { - type Program = U64TestProgram; - type Witness = U64TestWitness; - - const ZERO: u64 = 0; - const ONE: u64 = 1; - const MAX: u64 = u64::MAX; - const HALF_MAX: u64 = u64::MAX / 2; - const MUL_BOUND: u64 = 1 << 32; // 2^(64/2) - - fn program() -> U64TestProgram { - U64TestProgram::new(U64TestArguments {}) - } - - fn witness(op: u8, a: u64, b: u64, expected: Option) -> U64TestWitness { - U64TestWitness { - function_index: op, - first_arg: a, - second_arg: b, - expected, - ..Default::default() - } - } -} - -enum FunctionToTest { - U64Widen, -} - -#[inline] -fn op(o: FunctionToTest) -> u8 { - o as u8 + CUSTOM_BASE -} - -mod u64_tests { - use rand::Rng as _; - - use crate::FunctionToTest::U64Widen; - use crate::common::core::{Expect, run}; - - use super::*; - - // Stamps the 16 `#[simplex::test]` entry points for u64. Logic lives in common::uint. - uint_tests!(u64); - - #[simplex::test] - fn u64_into_u256(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..=u64::MAX); - - let mut expected_widen: [u8; 32] = [0u8; 32]; - expected_widen[24..32].copy_from_slice(&a.to_be_bytes()); - - run( - &context, - ::program(), - U64TestWitness { - function_index: op(U64Widen), - first_arg: a, - expected_widen, - ..Default::default() - }, - Expect::Ok, - ) - } -} From e519d7078d43da68e95506c1959e229ab06da30b Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 11 Aug 2026 20:14:37 +0300 Subject: [PATCH 2/4] typo --- simf/lib/u32/convert.simf | 4 ++-- simf/u32_convert_test.simf | 8 ++++---- tests/u32_convert_test.rs | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/simf/lib/u32/convert.simf b/simf/lib/u32/convert.simf index b5028bb..4145570 100644 --- a/simf/lib/u32/convert.simf +++ b/simf/lib/u32/convert.simf @@ -22,12 +22,12 @@ pub fn u32_to_u256(a: u32) -> u256 { /// Splitting uint conversions /// Splits u32 into four u8 -pub fn split_u32_to_u8(a: u32) -> (u8, u8, u8, u8) { +pub fn split_u32_into_u8(a: u32) -> (u8, u8, u8, u8) { ::into(a) } /// Splits u32 into two u16 -pub fn split_u32_to_u16(a: u32) -> (u16, u16) { +pub fn split_u32_into_u16(a: u32) -> (u16, u16) { ::into(a) } diff --git a/simf/u32_convert_test.simf b/simf/u32_convert_test.simf index af21275..b8dedee 100644 --- a/simf/u32_convert_test.simf +++ b/simf/u32_convert_test.simf @@ -2,8 +2,8 @@ use crate::lib::u32::convert::{ u32_to_u64, u32_to_u128, u32_to_u256, - split_u32_to_u8, - split_u32_to_u16, + split_u32_into_u8, + split_u32_into_u16, safe_u32_to_u1, safe_u32_to_u8, safe_u32_to_u16 @@ -46,7 +46,7 @@ fn main() { match if_test_this_function(3, fn_idx) { true => { - let (a3, a2, a1, a0): (u8, u8, u8, u8) = split_u32_to_u8(a); + let (a3, a2, a1, a0): (u8, u8, u8, u8) = split_u32_into_u8(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); @@ -67,7 +67,7 @@ fn main() { match if_test_this_function(4, fn_idx) { true => { - let (a1, a0): (u16, u16) = split_u32_to_u16(a); + let (a1, a0): (u16, u16) = split_u32_into_u16(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); diff --git a/tests/u32_convert_test.rs b/tests/u32_convert_test.rs index 860cab9..9efbe54 100644 --- a/tests/u32_convert_test.rs +++ b/tests/u32_convert_test.rs @@ -90,7 +90,7 @@ mod u32_convert_test { } #[simplex::test] - fn u32_convert_test_split_u32_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + fn u32_convert_test_split_u32_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u32::MAX); run( @@ -106,7 +106,7 @@ mod u32_convert_test { } #[simplex::test] - fn u32_convert_test_split_u32_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + fn u32_convert_test_split_u32_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u32::MAX); run( From 58d0dbe891e1693069a94dff47a49a5f56791576 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 16:45:56 +0300 Subject: [PATCH 3/4] returned u32 typo back, it will be fixed in upcoming pr; renamed to -> into for u64 --- simf/lib/u32/convert.simf | 4 ++-- simf/lib/u64/convert.simf | 4 ++-- simf/u32_convert_test.simf | 8 ++++---- simf/u64_convert_test.simf | 8 ++++---- tests/u32_convert_test.rs | 4 ++-- tests/u64_convert_test.rs | 12 ++++++------ 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/simf/lib/u32/convert.simf b/simf/lib/u32/convert.simf index 4145570..b5028bb 100644 --- a/simf/lib/u32/convert.simf +++ b/simf/lib/u32/convert.simf @@ -22,12 +22,12 @@ pub fn u32_to_u256(a: u32) -> u256 { /// Splitting uint conversions /// Splits u32 into four u8 -pub fn split_u32_into_u8(a: u32) -> (u8, u8, u8, u8) { +pub fn split_u32_to_u8(a: u32) -> (u8, u8, u8, u8) { ::into(a) } /// Splits u32 into two u16 -pub fn split_u32_into_u16(a: u32) -> (u16, u16) { +pub fn split_u32_to_u16(a: u32) -> (u16, u16) { ::into(a) } diff --git a/simf/lib/u64/convert.simf b/simf/lib/u64/convert.simf index b51a592..7161100 100644 --- a/simf/lib/u64/convert.simf +++ b/simf/lib/u64/convert.simf @@ -15,12 +15,12 @@ pub fn u64_to_u256(a: u64) -> u256 { /// Splitting uint conversions /// Splits u64 into four u16 -pub fn split_u64_to_u16(a: u64) -> (u16, u16, u16, u16) { +pub fn split_u64_into_u16(a: u64) -> (u16, u16, u16, u16) { ::into(a) } /// Splits u64 into two u32 -pub fn split_u64_to_u32(a: u64) -> (u32, u32) { +pub fn split_u64_into_u32(a: u64) -> (u32, u32) { ::into(a) } diff --git a/simf/u32_convert_test.simf b/simf/u32_convert_test.simf index b8dedee..af21275 100644 --- a/simf/u32_convert_test.simf +++ b/simf/u32_convert_test.simf @@ -2,8 +2,8 @@ use crate::lib::u32::convert::{ u32_to_u64, u32_to_u128, u32_to_u256, - split_u32_into_u8, - split_u32_into_u16, + split_u32_to_u8, + split_u32_to_u16, safe_u32_to_u1, safe_u32_to_u8, safe_u32_to_u16 @@ -46,7 +46,7 @@ fn main() { match if_test_this_function(3, fn_idx) { true => { - let (a3, a2, a1, a0): (u8, u8, u8, u8) = split_u32_into_u8(a); + let (a3, a2, a1, a0): (u8, u8, u8, u8) = split_u32_to_u8(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); @@ -67,7 +67,7 @@ fn main() { match if_test_this_function(4, fn_idx) { true => { - let (a1, a0): (u16, u16) = split_u32_into_u16(a); + let (a1, a0): (u16, u16) = split_u32_to_u16(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); diff --git a/simf/u64_convert_test.simf b/simf/u64_convert_test.simf index b706f55..de3ccf4 100644 --- a/simf/u64_convert_test.simf +++ b/simf/u64_convert_test.simf @@ -1,8 +1,8 @@ use crate::lib::u64::convert::{ u64_to_u128, u64_to_u256, - split_u64_to_u16, - split_u64_to_u32, + split_u64_into_u16, + split_u64_into_u32, safe_u64_to_u1, safe_u64_to_u8, safe_u64_to_u16, @@ -43,7 +43,7 @@ fn main() { match if_test_this_function(2, fn_idx) { true => { - let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_to_u16(a); + let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_into_u16(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let ( @@ -63,7 +63,7 @@ fn main() { match if_test_this_function(3, fn_idx) { true => { - let (a1, a0): (u32, u32) = split_u64_to_u32(a); + let (a1, a0): (u32, u32) = split_u64_into_u32(a); let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let (expected1, expected0): (u32, u32) = ::into(expected); diff --git a/tests/u32_convert_test.rs b/tests/u32_convert_test.rs index 9efbe54..860cab9 100644 --- a/tests/u32_convert_test.rs +++ b/tests/u32_convert_test.rs @@ -90,7 +90,7 @@ mod u32_convert_test { } #[simplex::test] - fn u32_convert_test_split_u32_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { + fn u32_convert_test_split_u32_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u32::MAX); run( @@ -106,7 +106,7 @@ mod u32_convert_test { } #[simplex::test] - fn u32_convert_test_split_u32_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { + fn u32_convert_test_split_u32_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u32::MAX); run( diff --git a/tests/u64_convert_test.rs b/tests/u64_convert_test.rs index d88fdaf..7cd28bd 100644 --- a/tests/u64_convert_test.rs +++ b/tests/u64_convert_test.rs @@ -13,8 +13,8 @@ use simplicityhl_std::artifacts::u64_convert_test::derived_u64_convert_test::{ enum FunctionToTest { U64ToU128, U64ToU256, - SplitU64ToU16, - SplitU64ToU32, + SplitU64IntoU16, + SplitU64IntoU32, SafeU64ToU1, SafeU64ToU8, SafeU64ToU16, @@ -74,14 +74,14 @@ mod u64_convert_test { } #[simplex::test] - fn u64_convert_test_split_u64_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + fn u64_convert_test_split_u64_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u64::MAX); run( &context, program(), build_witness( - op(FunctionToTest::SplitU64ToU16), + op(FunctionToTest::SplitU64IntoU16), a, U256::from(a).to_big_endian(), ), @@ -90,14 +90,14 @@ mod u64_convert_test { } #[simplex::test] - fn u64_convert_test_split_u64_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + fn u64_convert_test_split_u64_into_u32(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u64::MAX); run( &context, program(), build_witness( - op(FunctionToTest::SplitU64ToU32), + op(FunctionToTest::SplitU64IntoU32), a, U256::from(a).to_big_endian(), ), From 1bc9a6c29bf18f457d74165dc0a5ecd93d2e759f Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 14 Aug 2026 17:16:30 +0300 Subject: [PATCH 4/4] added missing split_u64_into_u8 --- simf/lib/u64/convert.simf | 5 ++++ simf/u64_convert_test.simf | 48 ++++++++++++++++++++++++++++++++++---- tests/u64_convert_test.rs | 17 ++++++++++++++ 3 files changed, 65 insertions(+), 5 deletions(-) diff --git a/simf/lib/u64/convert.simf b/simf/lib/u64/convert.simf index 7161100..8a7d985 100644 --- a/simf/lib/u64/convert.simf +++ b/simf/lib/u64/convert.simf @@ -14,6 +14,11 @@ pub fn u64_to_u256(a: u64) -> u256 { /// Splitting uint conversions +/// Splits u64 into eight u8 +pub fn split_u64_into_u8(a: u64) -> (u8, u8, u8, u8, u8, u8, u8, u8) { + ::into(a) +} + /// Splits u64 into four u16 pub fn split_u64_into_u16(a: u64) -> (u16, u16, u16, u16) { ::into(a) diff --git a/simf/u64_convert_test.simf b/simf/u64_convert_test.simf index de3ccf4..00d651e 100644 --- a/simf/u64_convert_test.simf +++ b/simf/u64_convert_test.simf @@ -1,6 +1,7 @@ use crate::lib::u64::convert::{ u64_to_u128, u64_to_u256, + split_u64_into_u8, split_u64_into_u16, split_u64_into_u32, safe_u64_to_u1, @@ -42,6 +43,43 @@ fn main() { }; match if_test_this_function(2, fn_idx) { + true => { + let ( + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = split_u64_into_u8(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let ( + expected7, + expected6, + expected5, + expected4, + expected3, + expected2, + expected1, + expected0 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected); + + assert_eq_8(a7, expected7); + assert_eq_8(a6, expected6); + assert_eq_8(a5, expected5); + assert_eq_8(a4, expected4); + assert_eq_8(a3, expected3); + assert_eq_8(a2, expected2); + assert_eq_8(a1, expected1); + assert_eq_8(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { true => { let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_into_u16(a); @@ -61,7 +99,7 @@ fn main() { false => {}, }; - match if_test_this_function(3, fn_idx) { + match if_test_this_function(4, fn_idx) { true => { let (a1, a0): (u32, u32) = split_u64_into_u32(a); @@ -74,7 +112,7 @@ fn main() { false => {}, }; - match if_test_this_function(4, fn_idx) { + match if_test_this_function(5, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u1 = jet::rightmost_64_1(expected); @@ -84,7 +122,7 @@ fn main() { false => {}, }; - match if_test_this_function(5, fn_idx) { + match if_test_this_function(6, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u8 = jet::rightmost_64_8(expected); @@ -94,7 +132,7 @@ fn main() { false => {}, }; - match if_test_this_function(6, fn_idx) { + match if_test_this_function(7, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u16 = jet::rightmost_64_16(expected); @@ -104,7 +142,7 @@ fn main() { false => {}, }; - match if_test_this_function(7, fn_idx) { + match if_test_this_function(8, fn_idx) { true => { let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); let expected: u32 = jet::rightmost_64_32(expected); diff --git a/tests/u64_convert_test.rs b/tests/u64_convert_test.rs index 7cd28bd..1a847f8 100644 --- a/tests/u64_convert_test.rs +++ b/tests/u64_convert_test.rs @@ -13,6 +13,7 @@ use simplicityhl_std::artifacts::u64_convert_test::derived_u64_convert_test::{ enum FunctionToTest { U64ToU128, U64ToU256, + SplitU64IntoU8, SplitU64IntoU16, SplitU64IntoU32, SafeU64ToU1, @@ -73,6 +74,22 @@ mod u64_convert_test { ) } + #[simplex::test] + fn u64_convert_test_split_u64_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64IntoU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + #[simplex::test] fn u64_convert_test_split_u64_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { let a = rand::thread_rng().gen_range(0..=u64::MAX);