From 13a8b182c1e9459ac283278fbc45aee7382824ae Mon Sep 17 00:00:00 2001 From: aritkulova Date: Sat, 15 Aug 2026 22:27:38 +0300 Subject: [PATCH 1/3] added convert functions for u256; splitted u256_math into bit and comparison --- simf/lib/u256/bit.simf | 71 +++ simf/lib/u256/comparison.simf | 49 +++ simf/lib/u256/convert.simf | 138 ++++++ simf/lib/{u256.simf => u256/math.simf} | 135 +----- simf/u256_convert_test.simf | 406 ++++++++++++++++++ simf/{u256_test.simf => u256_math_test.simf} | 7 +- ...test_split_add.simf => u256_test_add.simf} | 23 +- simf/u256_test_bits.simf | 7 +- simf/u256_test_compare.simf | 4 +- simf/u256_test_div.simf | 7 +- simf/u256_test_sub_mul.simf | 7 +- tests/u256_convert_test.rs | 331 ++++++++++++++ tests/{u256_test.rs => u256_math_test.rs} | 20 +- ...256_test_split_add.rs => u256_test_add.rs} | 37 +- tests/u256_test_compare.rs | 2 +- 15 files changed, 1040 insertions(+), 204 deletions(-) create mode 100644 simf/lib/u256/bit.simf create mode 100644 simf/lib/u256/comparison.simf create mode 100644 simf/lib/u256/convert.simf rename simf/lib/{u256.simf => u256/math.simf} (79%) create mode 100644 simf/u256_convert_test.simf rename simf/{u256_test.simf => u256_math_test.simf} (96%) rename simf/{u256_test_split_add.simf => u256_test_add.simf} (53%) create mode 100644 tests/u256_convert_test.rs rename tests/{u256_test.rs => u256_math_test.rs} (68%) rename tests/{u256_test_split_add.rs => u256_test_add.rs} (73%) diff --git a/simf/lib/u256/bit.simf b/simf/lib/u256/bit.simf new file mode 100644 index 0000000..e08a860 --- /dev/null +++ b/simf/lib/u256/bit.simf @@ -0,0 +1,71 @@ +use crate::lib::u128::{and_128, or_128, left_shift_128, right_shift_128}; + +/// Bit logic + +/// Bitwise AND of two 256-bit values +pub fn and_256(a: u256, b: u256) -> u256 { + let (a_high, a_low): (u128, u128) = ::into(a); + let (b_high, b_low): (u128, u128) = ::into(b); + + <(u128, u128)>::into((and_128(a_high, b_high), and_128(a_low, b_low))) +} + +/// Bitwise OR of two 256-bit values +pub fn or_256(a: u256, b: u256) -> u256 { + let (a_high, a_low): (u128, u128) = ::into(a); + let (b_high, b_low): (u128, u128) = ::into(b); + + <(u128, u128)>::into((or_128(a_high, b_high), or_128(a_low, b_low))) +} + +/// Left-shift a 256-bit value by the given amount. Bits are filled with zeroes +pub fn left_shift_256(shift: u8, a: u256) -> u256 { + match jet::is_zero_8(shift) { + true => a, + false => { + let (a_high, a_low): (u128, u128) = ::into(a); + + match jet::lt_8(shift, 128) { + true => { + let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(128, shift); // shift < 128 + let shifted_bits: u128 = right_shift_128(low_to_high_amount, a_low); + + let res_high: u128 = or_128(left_shift_128(shift, a_high), shifted_bits); + + <(u128, u128)>::into((res_high, left_shift_128(shift, a_low))) + }, + false => { + let (_, shift): (bool, u8) = jet::subtract_8(shift, 128); // shift >= 128 + + <(u128, u128)>::into((left_shift_128(shift, a_low), 0)) + } + } + } + } +} + +/// Right-shift a 256-bit value by the given amount. Bits are filled with zeroes +pub fn right_shift_256(shift: u8, a: u256) -> u256 { + match jet::is_zero_8(shift) { + true => a, + false => { + let (a_high, a_low): (u128, u128) = ::into(a); + + match jet::lt_8(shift, 128) { + true => { + let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(128, shift); // shift < 128 + let shifted_bits: u128 = left_shift_128(high_to_low_amount, a_high); + + let res_low: u128 = or_128(right_shift_128(shift, a_low), shifted_bits); + + <(u128, u128)>::into((right_shift_128(shift, a_high), res_low)) + }, + false => { + let (_, shift): (bool, u8) = jet::subtract_8(shift, 128); // shift >= 128 + + <(u128, u128)>::into((0, right_shift_128(shift, a_high))) + } + } + } + } +} diff --git a/simf/lib/u256/comparison.simf b/simf/lib/u256/comparison.simf new file mode 100644 index 0000000..437893c --- /dev/null +++ b/simf/lib/u256/comparison.simf @@ -0,0 +1,49 @@ +use crate::lib::binary::and; +use crate::lib::u128::{eq_128, is_zero_128, lt_128, le_128}; + +/// Comparison operations + +/// Checks if an integer is zero +pub fn is_zero_256(a: u256) -> bool { + let (a_high, a_low): (u128, u128) = ::into(a); + + and(is_zero_128(a_high), is_zero_128(a_low)) +} + +/// Checks if an integer is less than another integer +pub fn lt_256(a: u256, b: u256) -> bool { + let (a_high, a_low): (u128, u128) = ::into(a); + let (b_high, b_low): (u128, u128) = ::into(b); + + match lt_128(a_high, b_high) { + true => true, + false => match eq_128(a_high, b_high) { + true => lt_128(a_low, b_low), + false => false, + }, + } +} + +/// Checks if an integer is less than or equal to another integer +pub fn le_256(a: u256, b: u256) -> bool { + let (a_high, a_low): (u128, u128) = ::into(a); + let (b_high, b_low): (u128, u128) = ::into(b); + + match lt_128(a_high, b_high) { + true => true, + false => match eq_128(a_high, b_high) { + true => le_128(a_low, b_low), + false => false, + }, + } +} + +/// Check if an integer is greater than another integer +pub fn gt_256(a: u256, b: u256) -> bool { + lt_256(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_256(a: u256, b: u256) -> bool { + le_256(b, a) +} diff --git a/simf/lib/u256/convert.simf b/simf/lib/u256/convert.simf new file mode 100644 index 0000000..0e12ce1 --- /dev/null +++ b/simf/lib/u256/convert.simf @@ -0,0 +1,138 @@ +use crate::lib::u1::convert::u1_to_u256; +use crate::lib::u8::convert::u8_to_u256; +use crate::lib::u16::convert::u16_to_u256; +use crate::lib::u32::convert::u32_to_u256; +use crate::lib::u64::convert::u64_to_u256; +use crate::lib::u256::comparison::le_256; + +/// Splitting uint conversions + +/// Splits u256 into thirty two u8 +pub fn split_u256_into_u8( + a: u256 +) -> ( + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8 +) { + ::into(a) +} + +/// Splits u256 into sixteen u16 +pub fn split_u256_into_u16( + a: u256 +) -> (u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16) { + ::into(a) +} + +/// Splits u256 into eight u32 +pub fn split_u256_into_u32(a: u256) -> (u32, u32, u32, u32, u32, u32, u32, u32) { + ::into(a) +} + +/// Splits u256 into four u64 +pub fn split_u256_into_u64(a: u256) -> (u64, u64, u64, u64) { + ::into(a) +} + +/// Splits u256 into two u128 +pub fn split_u256_into_u128(a: u256) -> (u128, u128) { + ::into(a) +} + +/// Narrowing uint conversions + +/// Converts u256 into u1. +/// Panics if the value does not fit in u1 +pub fn safe_u256_to_u1(a: u256) -> u1 { + let u1_max: u256 = u1_to_u256(jet::high_1()); + let (_, _, _, a_64): (u64, u64, u64, u64) = split_u256_into_u64(a); + + assert!(le_256(a, u1_max)); + + jet::rightmost_64_1(a_64) +} + +/// Converts u256 into u8. +/// Panics if the value does not fit in u8 +pub fn safe_u256_to_u8(a: u256) -> u8 { + let u8_max: u256 = u8_to_u256(jet::high_8()); + let (_, _, _, a_64): (u64, u64, u64, u64) = split_u256_into_u64(a); + + assert!(le_256(a, u8_max)); + + jet::rightmost_64_8(a_64) +} + +/// Converts u256 into u16. +/// Panics if the value does not fit in u16 +pub fn safe_u256_to_u16(a: u256) -> u16 { + let u16_max: u256 = u16_to_u256(jet::high_16()); + let (_, _, _, a_64): (u64, u64, u64, u64) = split_u256_into_u64(a); + + assert!(le_256(a, u16_max)); + + jet::rightmost_64_16(a_64) +} + +/// Converts u256 into u32. +/// Panics if the value does not fit in u32 +pub fn safe_u256_to_u32(a: u256) -> u32 { + let u32_max: u256 = u32_to_u256(jet::high_32()); + let (_, _, _, a_64): (u64, u64, u64, u64) = split_u256_into_u64(a); + + assert!(le_256(a, u32_max)); + + jet::rightmost_64_32(a_64) +} + +/// Converts u256 into u64. +/// Panics if the value does not fit in u64 +pub fn safe_u256_to_u64(a: u256) -> u64 { + let u64_max: u256 = u64_to_u256(jet::high_64()); + let (_, _, _, a_64): (u64, u64, u64, u64) = split_u256_into_u64(a); + + assert!(le_256(a, u64_max)); + + a_64 +} + +/// Converts u256 into u128. +/// Panics if the value does not fit in u128 +pub fn safe_u256_to_u128(a: u256) -> u128 { + let u128_max: u256 = 0x00000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; + let (_, a_128): (u128, u128) = split_u256_into_u128(a); + + assert!(le_256(a, u128_max)); + + a_128 +} diff --git a/simf/lib/u256.simf b/simf/lib/u256/math.simf similarity index 79% rename from simf/lib/u256.simf rename to simf/lib/u256/math.simf index fcbe0a8..c88638e 100644 --- a/simf/lib/u256.simf +++ b/simf/lib/u256/math.simf @@ -1,13 +1,8 @@ use crate::lib::binary::{not, and}; use crate::lib::u128::{ - and_128, - or_128, eq_128, - left_shift_128, - right_shift_128, is_zero_128, lt_128, - le_128, add_128, full_add_128, sub_128, @@ -20,129 +15,11 @@ use crate::lib::u128::{ div_mod_128, div_mod_128_64 }; - -/// Bit logic - -/// Bitwise AND of two 256-bit values -pub fn and_256(a: u256, b: u256) -> u256 { - let (a_high, a_low): (u128, u128) = ::into(a); - let (b_high, b_low): (u128, u128) = ::into(b); - - <(u128, u128)>::into((and_128(a_high, b_high), and_128(a_low, b_low))) -} - -/// Bitwise OR of two 256-bit values -pub fn or_256(a: u256, b: u256) -> u256 { - let (a_high, a_low): (u128, u128) = ::into(a); - let (b_high, b_low): (u128, u128) = ::into(b); - - <(u128, u128)>::into((or_128(a_high, b_high), or_128(a_low, b_low))) -} - -/// Left-shift a 256-bit value by the given amount. Bits are filled with zeroes -pub fn left_shift_256(shift: u8, a: u256) -> u256 { - match jet::is_zero_8(shift) { - true => a, - false => { - let (a_high, a_low): (u128, u128) = ::into(a); - - match jet::lt_8(shift, 128) { - true => { - let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(128, shift); // shift < 128 - let shifted_bits: u128 = right_shift_128(low_to_high_amount, a_low); - - let res_high: u128 = or_128(left_shift_128(shift, a_high), shifted_bits); - - <(u128, u128)>::into((res_high, left_shift_128(shift, a_low))) - }, - false => { - let (_, shift): (bool, u8) = jet::subtract_8(shift, 128); // shift >= 128 - - <(u128, u128)>::into((left_shift_128(shift, a_low), 0)) - } - } - } - } -} - -/// Right-shift a 256-bit value by the given amount. Bits are filled with zeroes -pub fn right_shift_256(shift: u8, a: u256) -> u256 { - match jet::is_zero_8(shift) { - true => a, - false => { - let (a_high, a_low): (u128, u128) = ::into(a); - - match jet::lt_8(shift, 128) { - true => { - let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(128, shift); // shift < 128 - let shifted_bits: u128 = left_shift_128(high_to_low_amount, a_high); - - let res_low: u128 = or_128(right_shift_128(shift, a_low), shifted_bits); - - <(u128, u128)>::into((right_shift_128(shift, a_high), res_low)) - }, - false => { - let (_, shift): (bool, u8) = jet::subtract_8(shift, 128); // shift >= 128 - - <(u128, u128)>::into((0, right_shift_128(shift, a_high))) - } - } - } - } -} +use crate::lib::u256::convert::split_u256_into_u64; +use crate::lib::u256::comparison::{is_zero_256, lt_256}; /// Arithmetic -/// Checks if an integer is zero -pub fn is_zero_256(a: u256) -> bool { - let (a_high, a_low): (u128, u128) = ::into(a); - - and(is_zero_128(a_high), is_zero_128(a_low)) -} - -/// Checks if an integer is less than another integer -pub fn lt_256(a: u256, b: u256) -> bool { - let (a_high, a_low): (u128, u128) = ::into(a); - let (b_high, b_low): (u128, u128) = ::into(b); - - match lt_128(a_high, b_high) { - true => true, - false => match eq_128(a_high, b_high) { - true => lt_128(a_low, b_low), - false => false, - }, - } -} - -/// Checks if an integer is less than or equal to another integer -pub fn le_256(a: u256, b: u256) -> bool { - let (a_high, a_low): (u128, u128) = ::into(a); - let (b_high, b_low): (u128, u128) = ::into(b); - - match lt_128(a_high, b_high) { - true => true, - false => match eq_128(a_high, b_high) { - true => le_128(a_low, b_low), - false => false, - }, - } -} - -/// Check if an integer is greater than another integer -pub fn gt_256(a: u256, b: u256) -> bool { - lt_256(b, a) -} - -/// Check if an integer is greater than or equal to another integer -pub fn ge_256(a: u256, b: u256) -> bool { - le_256(b, a) -} - -/// Splits the u256 integer into four u64 integers -pub fn split_256_into_64(a: u256) -> (u64, u64, u64, u64) { - ::into(a) -} - /// Adds two integers and returns the carry pub fn add_256(a: u256, b: u256) -> (bool, u256) { let (a_high, a_low): (u128, u128) = ::into(a); @@ -370,7 +247,7 @@ fn normalize_to_threshold_256_127(a: u256, b: u256) -> (u128, u256, u256) { /// Divides the 256-bit integer by the 64-bit integer, /// returns a tuple of the u256 quotient and the u64 remainder pub fn div_mod_256_64(dividend: u256, divisor: u64) -> (u256, u64) { - let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_256_into_64(dividend); + let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_u256_into_u64(dividend); // calculate the upper part of the quotient let (q3, remainder): (u64, u64) = jet::div_mod_64(u3, divisor); @@ -383,7 +260,7 @@ pub fn div_mod_256_64(dividend: u256, divisor: u64) -> (u256, u64) { let (_, norm_dividend_low, norm_divisor, norm): (u64, u256, u128, u64) = normalize_to_threshold_256_63(dividend, divisor, false); - let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_256_into_64(norm_dividend_low); + let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_u256_into_u64(norm_dividend_low); let (_, v0): (u64, u64) = ::into(norm_divisor); let (q2, remainder): (u64, u64) = jet::div_mod_128_64( <(u64, u64)>::into((u3, u2)), v0); @@ -405,7 +282,7 @@ fn mul_and_sub(q: u64, u2: u64, u1: u64, u0: u64, v: u128) -> (u64, u64) { let q_v: u256 = mul_128_64(v, q); let u_updated: u256 = safe_sub_256(u, q_v); - let (_, _, u1, u0): (u64, u64, u64, u64) = split_256_into_64(u_updated); + let (_, _, u1, u0): (u64, u64, u64, u64) = split_u256_into_u64(u_updated); (u1, u0) } @@ -419,7 +296,7 @@ fn algorithm_d_256_128(dividend: u256, divisor: u128) -> (u256, u128) { normalize_to_threshold_256_63(dividend, divisor, true); // normalized dividend fits into 320 bits - let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_256_into_64(norm_dividend_low); + let (u3, u2, u1, u0): (u64, u64, u64, u64) = split_u256_into_u64(norm_dividend_low); let (v1, v0): (u64, u64) = ::into(norm_divisor); let q2: u64 = estimate_quotient_digit_base_64(u4, u3, u2, v1, v0); diff --git a/simf/u256_convert_test.simf b/simf/u256_convert_test.simf new file mode 100644 index 0000000..fe659dd --- /dev/null +++ b/simf/u256_convert_test.simf @@ -0,0 +1,406 @@ +use crate::lib::u256::convert::{ + split_u256_into_u8, + split_u256_into_u16, + split_u256_into_u32, + split_u256_into_u64, + split_u256_into_u128, + safe_u256_to_u1, + safe_u256_to_u8, + safe_u256_to_u16, + safe_u256_to_u32, + safe_u256_to_u64, + safe_u256_to_u128 +}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_64, + assert_eq_128 +}; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u256 = witness::FIRST_ARG; + + let expected: u256 = witness::EXPECTED; + + match if_test_this_function(0, fn_idx) { + true => { + let ( + a31, + a30, + a29, + a28, + a27, + a26, + a25, + a24, + a23, + a22, + a21, + a20, + a19, + a18, + a17, + a16, + a15, + a14, + a13, + a12, + a11, + a10, + a9, + a8, + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): ( + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8, + u8 + ) = split_u256_into_u8(a); + + let ( + expected3, + expected2, + expected1, + expected0 + ): (u64, u64, u64, u64) = ::into(expected); + + let ( + expected31, + expected30, + expected29, + expected28, + expected27, + expected26, + expected25, + expected24 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected3); + + let ( + expected23, + expected22, + expected21, + expected20, + expected19, + expected18, + expected17, + expected16 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected2); + + let ( + expected15, + expected14, + expected13, + expected12, + expected11, + expected10, + expected9, + expected8 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected1); + + let ( + expected7, + expected6, + expected5, + expected4, + expected3, + expected2, + expected1, + expected0 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected0); + + assert_eq_8(a31, expected31); + assert_eq_8(a30, expected30); + assert_eq_8(a29, expected29); + assert_eq_8(a28, expected28); + assert_eq_8(a27, expected27); + assert_eq_8(a26, expected26); + assert_eq_8(a25, expected25); + assert_eq_8(a24, expected24); + assert_eq_8(a23, expected23); + assert_eq_8(a22, expected22); + assert_eq_8(a21, expected21); + assert_eq_8(a20, expected20); + assert_eq_8(a19, expected19); + assert_eq_8(a18, expected18); + assert_eq_8(a17, expected17); + assert_eq_8(a16, expected16); + assert_eq_8(a15, expected15); + assert_eq_8(a14, expected14); + assert_eq_8(a13, expected13); + assert_eq_8(a12, expected12); + assert_eq_8(a11, expected11); + assert_eq_8(a10, expected10); + assert_eq_8(a9, expected9); + assert_eq_8(a8, expected8); + 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(1, fn_idx) { + true => { + let ( + a15, + a14, + a13, + a12, + a11, + a10, + a9, + a8, + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): ( + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16, + u16 + ) = split_u256_into_u16(a); + + let ( + expected3, + expected2, + expected1, + expected0 + ): (u64, u64, u64, u64) = ::into(expected); + + let ( + expected15, + expected14, + expected13, + expected12 + ): (u16, u16, u16, u16) = ::into(expected3); + let ( + expected11, + expected10, + expected9, + expected8 + ): (u16, u16, u16, u16) = ::into(expected2); + let ( + expected7, + expected6, + expected5, + expected4 + ): (u16, u16, u16, u16) = ::into(expected1); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u16, u16, u16, u16) = ::into(expected0); + + assert_eq_16(a15, expected15); + assert_eq_16(a14, expected14); + assert_eq_16(a13, expected13); + assert_eq_16(a12, expected12); + assert_eq_16(a11, expected11); + assert_eq_16(a10, expected10); + assert_eq_16(a9, expected9); + assert_eq_16(a8, expected8); + assert_eq_16(a7, expected7); + assert_eq_16(a6, expected6); + assert_eq_16(a5, expected5); + assert_eq_16(a4, expected4); + 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(2, fn_idx) { + true => { + let ( + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): (u32, u32, u32, u32, u32, u32, u32, u32) = split_u256_into_u32(a); + + let (expected1, expected0): (u128, u128) = ::into(expected); + + let ( + expected7, + expected6, + expected5, + expected4 + ): (u32, u32, u32, u32) = ::into(expected1); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u32, u32, u32, u32) = ::into(expected0); + + assert_eq_32(a7, expected7); + assert_eq_32(a6, expected6); + assert_eq_32(a5, expected5); + assert_eq_32(a4, expected4); + assert_eq_32(a3, expected3); + assert_eq_32(a2, expected2); + assert_eq_32(a1, expected1); + assert_eq_32(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (a3, a2, a1, a0): (u64, u64, u64, u64) = split_u256_into_u64(a); + + let ( + expected3, + expected2, + expected1, + expected0 + ): (u64, u64, u64, u64) = ::into(expected); + + assert_eq_64(a3, expected3); + assert_eq_64(a2, expected2); + assert_eq_64(a1, expected1); + assert_eq_64(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + let (a1, a0): (u128, u128) = split_u256_into_u128(a); + + let (expected1, expected0): (u128, u128) = ::into(expected); + + assert_eq_128(a1, expected1); + assert_eq_128(a0, expected0); + }, + false => {}, + }; + + 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); + + assert_eq_1(safe_u256_to_u1(a), expected); + }, + false => {}, + }; + + 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); + + assert_eq_8(safe_u256_to_u8(a), expected); + }, + false => {}, + }; + + 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); + + assert_eq_16(safe_u256_to_u16(a), expected); + }, + false => {}, + }; + + 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); + + assert_eq_32(safe_u256_to_u32(a), expected); + }, + false => {}, + }; + + match if_test_this_function(9, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + + assert_eq_64(safe_u256_to_u64(a), expected); + }, + false => {}, + }; + + match if_test_this_function(10, fn_idx) { + true => { + let (_, expected): (u128, u128) = ::into(expected); + + assert_eq_128(safe_u256_to_u128(a), expected); + }, + false => {}, + }; +} diff --git a/simf/u256_test.simf b/simf/u256_math_test.simf similarity index 96% rename from simf/u256_test.simf rename to simf/u256_math_test.simf index 3cb186d..9bc8930 100644 --- a/simf/u256_test.simf +++ b/simf/u256_math_test.simf @@ -1,4 +1,4 @@ -use crate::lib::u256::{ +use crate::lib::u256::math::{ checked_add_256, safe_add_256, checked_sub_256, @@ -6,10 +6,9 @@ use crate::lib::u256::{ checked_mul_256, safe_mul_256, checked_div_256, - safe_div_256, - gt_256, - ge_256 + safe_div_256 }; +use crate::lib::u256::comparison::{gt_256, ge_256}; use crate::lib::asserts::{assert_none_256, assert_eq_256}; use crate::lib::binary::not; use crate::helper::if_test_this_function; diff --git a/simf/u256_test_split_add.simf b/simf/u256_test_add.simf similarity index 53% rename from simf/u256_test_split_add.simf rename to simf/u256_test_add.simf index da49048..1c06f46 100644 --- a/simf/u256_test_split_add.simf +++ b/simf/u256_test_add.simf @@ -1,4 +1,4 @@ -use crate::lib::u256::{split_256_into_64, add_256, add_256_128}; +use crate::lib::u256::math::{add_256, add_256_128}; use crate::lib::asserts::assert_eq_256; use crate::helper::{if_test_this_function, assert_bool}; @@ -22,23 +22,6 @@ fn main() { /// Arithmetic - match if_test_this_function(0, fn_idx) { - true => { - let (res1, res2, res3, res4): (u64, u64, u64, u64) = split_256_into_64(a); - - let (high, low): (u128, u128) = ::into(unwrap(expected)); - - let (expected1, expected2): (u64, u64) = ::into(high); - let (expected3, expected4): (u64, u64) = ::into(low); - - assert!(jet::eq_64(res1, expected1)); - assert!(jet::eq_64(res2, expected2)); - assert!(jet::eq_64(res3, expected3)); - assert!(jet::eq_64(res4, expected4)); - }, - false => (), - }; - - match if_test_this_function(1, fn_idx) { true => { assert_eq_uint_bool(add_256(a, b), unwrap(expected), expected_bool); }, false => (), }; - match if_test_this_function(2, fn_idx) { true => { let (_, b): (u128, u128) = ::into(b); assert_eq_uint_bool(add_256_128(a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(0, fn_idx) { true => { assert_eq_uint_bool(add_256(a, b), unwrap(expected), expected_bool); }, false => (), }; + match if_test_this_function(1, fn_idx) { true => { let (_, b): (u128, u128) = ::into(b); assert_eq_uint_bool(add_256_128(a, b), unwrap(expected), expected_bool); }, false => (), }; } diff --git a/simf/u256_test_bits.simf b/simf/u256_test_bits.simf index 4739fcd..797c0e8 100644 --- a/simf/u256_test_bits.simf +++ b/simf/u256_test_bits.simf @@ -1,4 +1,5 @@ -use crate::lib::u256::{and_256, or_256, left_shift_256, right_shift_256, split_256_into_64}; +use crate::lib::u256::bit::{and_256, or_256, left_shift_256, right_shift_256}; +use crate::lib::u256::convert::split_u256_into_u64; use crate::lib::asserts::assert_eq_256; use crate::helper::if_test_this_function; @@ -16,7 +17,7 @@ fn main() { match if_test_this_function(2, fn_idx) { true => { - let (_, _, _, a): (u64, u64, u64, u64) = split_256_into_64(a); + let (_, _, _, a): (u64, u64, u64, u64) = split_u256_into_u64(a); let shift: u8 = jet::rightmost_64_8(a); assert_eq_256(left_shift_256(shift, b), unwrap(expected)); @@ -25,7 +26,7 @@ fn main() { match if_test_this_function(3, fn_idx) { true => { - let (_, _, _, a): (u64, u64, u64, u64) = split_256_into_64(a); + let (_, _, _, a): (u64, u64, u64, u64) = split_u256_into_u64(a); let shift: u8 = jet::rightmost_64_8(a); assert_eq_256(right_shift_256(shift, b), unwrap(expected)); diff --git a/simf/u256_test_compare.simf b/simf/u256_test_compare.simf index 7deedb5..5192369 100644 --- a/simf/u256_test_compare.simf +++ b/simf/u256_test_compare.simf @@ -1,4 +1,4 @@ -use crate::lib::u256::{is_zero_256, lt_256, le_256}; +use crate::lib::u256::comparison::{is_zero_256, lt_256, le_256}; use crate::helper::{if_test_this_function, assert_bool}; fn main() { @@ -8,7 +8,7 @@ fn main() { let b: u256 = witness::SECOND_ARG; let expected_bool: bool = witness::EXPECTED_BOOL; - /// Arithmetic + /// Comparison operations match if_test_this_function(0, fn_idx) { true => { assert_bool(is_zero_256(a), expected_bool); }, false => (), }; match if_test_this_function(1, fn_idx) { true => { assert_bool(lt_256(a, b), expected_bool); }, false => (), }; diff --git a/simf/u256_test_div.simf b/simf/u256_test_div.simf index 50576b1..7c895b2 100644 --- a/simf/u256_test_div.simf +++ b/simf/u256_test_div.simf @@ -1,4 +1,5 @@ -use crate::lib::u256::{div_mod_256_64, div_mod_256_128, div_mod_256, div_256, split_256_into_64}; +use crate::lib::u256::math::{div_mod_256_64, div_mod_256_128, div_mod_256, div_256}; +use crate::lib::u256::convert::split_u256_into_u64; use crate::lib::asserts::{assert_eq_128, assert_eq_256}; use crate::helper::if_test_this_function; @@ -15,8 +16,8 @@ fn main() { match if_test_this_function(0, fn_idx) { true => { - let (_, _, _, b): (u64, u64, u64, u64) = split_256_into_64(b); - let (_, _, _, expected_r): (u64, u64, u64, u64) = split_256_into_64(second_expected); + let (_, _, _, b): (u64, u64, u64, u64) = split_u256_into_u64(b); + let (_, _, _, expected_r): (u64, u64, u64, u64) = split_u256_into_u64(second_expected); let (q, r): (u256, u64) = div_mod_256_64(a, b); diff --git a/simf/u256_test_sub_mul.simf b/simf/u256_test_sub_mul.simf index 2ca3442..aa6b673 100644 --- a/simf/u256_test_sub_mul.simf +++ b/simf/u256_test_sub_mul.simf @@ -1,4 +1,5 @@ -use crate::lib::u256::{sub_256, mul_256, mul_256_64, mul_256_128, split_256_into_64}; +use crate::lib::u256::math::{sub_256, mul_256, mul_256_64, mul_256_128}; +use crate::lib::u256::convert::split_u256_into_u64; use crate::lib::asserts::{assert_eq_64, assert_eq_128, assert_eq_256}; use crate::helper::{if_test_this_function, assert_bool}; @@ -38,8 +39,8 @@ fn main() { match if_test_this_function(2, fn_idx) { true => { - let (_, _, _, b): (u64, u64, u64, u64) = split_256_into_64(b); - let (_, _, _, expected): (u64, u64, u64, u64) = split_256_into_64(unwrap(expected)); + let (_, _, _, b): (u64, u64, u64, u64) = split_u256_into_u64(b); + let (_, _, _, expected): (u64, u64, u64, u64) = split_u256_into_u64(unwrap(expected)); let (result_high, result_low): (u64, u256) = mul_256_64(a, b); diff --git a/tests/u256_convert_test.rs b/tests/u256_convert_test.rs new file mode 100644 index 0000000..2f31be6 --- /dev/null +++ b/tests/u256_convert_test.rs @@ -0,0 +1,331 @@ +mod common; + +use primitive_types::U256; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u256_convert_test::U256ConvertTestProgram; +use simplicityhl_std::artifacts::u256_convert_test::derived_u256_convert_test::{ + U256ConvertTestArguments, U256ConvertTestWitness, +}; + +enum FunctionToTest { + SplitU256IntoU8, + SplitU256IntoU16, + SplitU256IntoU32, + SplitU256IntoU64, + SplitU256IntoU128, + SafeU256ToU1, + SafeU256ToU8, + SafeU256ToU16, + SafeU256ToU32, + SafeU256ToU64, + SafeU256ToU128, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U256ConvertTestProgram { + U256ConvertTestProgram::new(U256ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: [u8; 32], expected: [u8; 32]) -> U256ConvertTestWitness { + U256ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u256_convert_test { + use crate::common::helper::generate_u256; + + use super::*; + + #[simplex::test] + fn u256_convert_test_u256_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU256IntoU8), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_u256_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU256IntoU16), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_u256_into_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU256IntoU32), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_u256_into_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU256IntoU64), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_u256_into_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU256IntoU128), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::one()); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU1), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u1_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(2), U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU1), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::from(u8::MAX)); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU8), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u8_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(u8::MAX) + 1, U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU8), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::from(u16::MAX)); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU16), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u16_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(u16::MAX) + 1, U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU16), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::from(u32::MAX)); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU32), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u32_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(u32::MAX) + 1, U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU32), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::from(u64::MAX)); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU64), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u64_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(u64::MAX) + 1, U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU64), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = generate_u256(U256::zero(), U256::from(u128::MAX)); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU128), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u256_convert_test_safe_u256_to_u128_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = generate_u256(U256::from(u128::MAX) + 1, U256::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU256ToU128), + a.to_big_endian(), + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } +} diff --git a/tests/u256_test.rs b/tests/u256_math_test.rs similarity index 68% rename from tests/u256_test.rs rename to tests/u256_math_test.rs index d15c05d..2d407be 100644 --- a/tests/u256_test.rs +++ b/tests/u256_math_test.rs @@ -5,15 +5,15 @@ use primitive_types::U256; use common::u256_wrapper::U256Wrapper; use common::uint::TestUint; -use simplicityhl_std::artifacts::u256_test::U256TestProgram; -use simplicityhl_std::artifacts::u256_test::derived_u256_test::{ - U256TestArguments, U256TestWitness, +use simplicityhl_std::artifacts::u256_math_test::U256MathTestProgram; +use simplicityhl_std::artifacts::u256_math_test::derived_u256_math_test::{ + U256MathTestArguments, U256MathTestWitness, }; // The only per-width code for the common operations. impl TestUint for U256Wrapper { - type Program = U256TestProgram; - type Witness = U256TestWitness; + type Program = U256MathTestProgram; + type Witness = U256MathTestWitness; const ZERO: U256Wrapper = U256Wrapper(U256::zero()); const ONE: U256Wrapper = U256Wrapper(U256::one()); @@ -21,8 +21,8 @@ impl TestUint for U256Wrapper { const HALF_MAX: U256Wrapper = U256Wrapper(U256([u64::MAX, u64::MAX, u64::MAX, u64::MAX >> 1])); const MUL_BOUND: U256Wrapper = U256Wrapper(U256([0, 0, 1, 0])); // 2^(256/2) - fn program() -> U256TestProgram { - U256TestProgram::new(U256TestArguments {}) + fn program() -> U256MathTestProgram { + U256MathTestProgram::new(U256MathTestArguments {}) } fn witness( @@ -30,8 +30,8 @@ impl TestUint for U256Wrapper { a: U256Wrapper, b: U256Wrapper, expected: Option, - ) -> U256TestWitness { - U256TestWitness { + ) -> U256MathTestWitness { + U256MathTestWitness { function_index: op, first_arg: a.to_big_endian(), second_arg: b.to_big_endian(), @@ -40,7 +40,7 @@ impl TestUint for U256Wrapper { } } -mod u256_tests { +mod u256_math_tests { use super::*; // Stamps the 22 `#[simplex::test]` entry points for U256Wrapper. Logic lives in common::uint. diff --git a/tests/u256_test_split_add.rs b/tests/u256_test_add.rs similarity index 73% rename from tests/u256_test_split_add.rs rename to tests/u256_test_add.rs index 18898c9..f7792f7 100644 --- a/tests/u256_test_split_add.rs +++ b/tests/u256_test_add.rs @@ -2,16 +2,15 @@ mod common; use primitive_types::U256; -use crate::common::helper::{DEFAULT_BOOL, generate_u256}; +use crate::common::helper::generate_u256; use common::core::{Expect, run}; -use simplicityhl_std::artifacts::u256_test_split_add::U256TestSplitAddProgram; -use simplicityhl_std::artifacts::u256_test_split_add::derived_u256_test_split_add::{ - U256TestSplitAddArguments, U256TestSplitAddWitness, +use simplicityhl_std::artifacts::u256_test_add::U256TestAddProgram; +use simplicityhl_std::artifacts::u256_test_add::derived_u256_test_add::{ + U256TestAddArguments, U256TestAddWitness, }; enum FunctionToTest { - Split256Into64, Add256, Add256_128, } @@ -21,10 +20,8 @@ fn op(o: FunctionToTest) -> u8 { o as u8 } -const DEFAULT_EXPECTED: [u8; 32] = [0; 32]; - -fn program() -> U256TestSplitAddProgram { - U256TestSplitAddProgram::new(U256TestSplitAddArguments {}) +fn program() -> U256TestAddProgram { + U256TestAddProgram::new(U256TestAddArguments {}) } fn build_witness( @@ -33,8 +30,8 @@ fn build_witness( b: [u8; 32], expected: Option<[u8; 32]>, expected_bool: bool, -) -> U256TestSplitAddWitness { - U256TestSplitAddWitness { +) -> U256TestAddWitness { + U256TestAddWitness { function_index: function, first_arg: a, second_arg: b, @@ -46,24 +43,6 @@ fn build_witness( mod u256_tests_arithmetic { use super::*; - #[simplex::test] - fn u256_test_split_256_into_64(context: simplex::TestContext) -> anyhow::Result<()> { - let a = generate_u256(U256::one(), U256::MAX).to_big_endian(); - - run( - &context, - program(), - build_witness( - op(FunctionToTest::Split256Into64), - a, - DEFAULT_EXPECTED, - Some(a), - DEFAULT_BOOL, - ), - Expect::Ok, - ) - } - #[simplex::test] fn u256_test_add_256_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> { let a = generate_u256(U256::zero(), U256::MAX / 2); diff --git a/tests/u256_test_compare.rs b/tests/u256_test_compare.rs index 0ed9e83..eea807d 100644 --- a/tests/u256_test_compare.rs +++ b/tests/u256_test_compare.rs @@ -41,7 +41,7 @@ fn build_witness( } } -mod u256_tests_arithmetic { +mod u256_tests_compare { use super::*; #[simplex::test] From c718bdf7a04f4dbeed501f73783a22ff48a18f66 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Sun, 16 Aug 2026 13:42:40 +0300 Subject: [PATCH 2/3] updated readme --- README.md | 42 +++++++++++++++++++++++++++++++++--------- 1 file changed, 33 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index e607392..9c489e8 100644 --- a/README.md +++ b/README.md @@ -15,20 +15,44 @@ simf/lib │ ├── Subtraction for `Fe`, `Scalar`, `Gej`. │ ├── Equality predicates and their `assert_*` counterparts. │ └── Safe Jacobian-to-affine normalization. +├── u1 +│ └── convert.simf +├── u8 +│ ├── convert.simf +│ └── math.simf +├── u16 +│ ├── convert.simf +│ └── math.simf +├── u32 +│ ├── convert.simf +│ └── math.simf +├── u64 +│ ├── convert.simf +│ └── math.simf +├── u128 +│ ├── bit.simf +│ │ └── Basic bit operations that are available as jets for `u8`–`u64` but are missing for `u128`. +│ ├── comparison.simf +│ │ └── Basic comparison operations that are available as jets for `u8`–`u64` but are missing for `u128`. +│ ├── convert.simf +│ │ └── Conversions between `u128` and other uint types. +│ └── math.simf +│ └── Overflow-checked arithmetic operations. +├── u256 +│ ├── bit.simf +│ │ └── Basic bit operations that are available as jets for `u8`–`u64` but are missing for `u256`. +│ ├── comparison.simf +│ │ └── Basic comparison operations that are available as jets for `u8`–`u64` but are missing for `u256`. +│ ├── convert.simf +│ │ └── Conversions between `u256` and other uint types. +│ └── math.simf +│ └── Overflow-checked arithmetic operations. ├── asserts.simf │ └── Generic assertion helpers with equality checks between uint values. ├── binary.simf │ └── Basic binary logic operations: `and`, `or`, `not`, `xor`. ├── op_return.simf -│ └── Utilities for detecting and enforcing `OP_RETURN` (null data) outputs. -├── u8.simf -├── u16.simf -├── u32.simf -├── u64.simf -└── u128.simf - ├── Overflow-checked arithmetic operations. - ├── Comparison helpers. - └── Basic operations that are available as jets for `u8`-`u64` but are missing for `u128`. + └── Utilities for detecting and enforcing `OP_RETURN` (null data) outputs. ``` ## Installation From c53f4304e9afd4fe5d9b99b8f09a615354a088be Mon Sep 17 00:00:00 2001 From: aritkulova Date: Sun, 16 Aug 2026 13:52:13 +0300 Subject: [PATCH 3/3] bumped simplex version --- Cargo.lock | 249 ++++++++++++++++++++++++++++------------------------- Cargo.toml | 2 +- 2 files changed, 132 insertions(+), 119 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e9dcc4c..4ccea75 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,9 +4,9 @@ version = 4 [[package]] name = "aho-corasick" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" dependencies = [ "memchr", ] @@ -69,15 +69,15 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.103" +version = "1.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" [[package]] name = "ar_archive_writer" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348" +checksum = "73cd58deff2140a0a8eae87e417bd01db68a33e148aa93d1e8cd837e55e312b6" dependencies = [ "object", ] @@ -96,9 +96,9 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" [[package]] name = "aws-lc-rs" -version = "1.17.1" +version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4342d8937fc7e5dd9b1c60292261c0670c882a2cd1719cfc11b1af41731e32ad" +checksum = "ce2b2dcc879c3bae0d371e77c99f2238400ef24ec001394befa67b6e543add9e" dependencies = [ "aws-lc-sys", "zeroize", @@ -106,9 +106,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.42.0" +version = "0.44.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d9ceb1da931507a12f4fccea479dccd00da1943e1b4ae72d8e502d707361444" +checksum = "f09fae7be8bb3174e05c6afdb34199e6dc0c7c04ba9fa237b1967adfbde27483" dependencies = [ "cc", "cmake", @@ -177,9 +177,9 @@ dependencies = [ [[package]] name = "bitcoin-consensus-encoding" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "207311705279250ba465076a1bac4b1ac982855fff73fc5f67e22158ac58cdc9" +checksum = "6712f9c6fd6785b3b270884e57c441c403dc5d7e19ca45368c97c7a1de3000ec" dependencies = [ "bitcoin-internals", "hex-conservative 1.2.0", @@ -300,9 +300,9 @@ dependencies = [ [[package]] name = "bstr" -version = "1.13.0" +version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f7dc094d718f2e1c1559ad110e27eeaae14a5465d3d56dd6dbd793079fbd530" +checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f" dependencies = [ "memchr", "serde_core", @@ -328,9 +328,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "cc" -version = "1.2.67" +version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38" +checksum = "509591b7bcd67f4ef775afad7662703b4935daaa6ec0e5605cfb1090b32a2b6d" dependencies = [ "find-msvc-tools", "jobserver", @@ -360,18 +360,18 @@ dependencies = [ [[package]] name = "clap" -version = "4.6.2" +version = "4.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd059f9da4f5c36b3787f65d38ccaab1cc315f07b01f89abc8359ee6a8205011" +checksum = "473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca" dependencies = [ "clap_builder", ] [[package]] name = "clap_builder" -version = "4.6.2" +version = "4.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f09628afdcc538b57f3c6341e9c8e9970f18e4a481690a64974d7023bd33548b" +checksum = "7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889" dependencies = [ "anstream", "anstyle", @@ -496,9 +496,9 @@ checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" [[package]] name = "either" -version = "1.16.0" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" +checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d" dependencies = [ "serde", ] @@ -571,15 +571,15 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.4.1" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" [[package]] name = "find-msvc-tools" -version = "0.1.9" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" +checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890" [[package]] name = "fixed-hash" @@ -613,21 +613,21 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures-core" -version = "0.3.32" +version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" [[package]] name = "futures-task" -version = "0.3.32" +version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" [[package]] name = "futures-util" -version = "0.3.32" +version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" dependencies = [ "futures-core", "futures-task", @@ -677,20 +677,20 @@ checksum = "d8449d342b1c67f49169e92e71deb7b9b27f30062301a16dbc27a4cc8d2351b7" [[package]] name = "glob" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" [[package]] name = "globset" -version = "0.4.19" +version = "0.4.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e47d37d2ae4464254884b60ab7071be2b876a9c35b696bd018ddcc76847309cd" +checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988" dependencies = [ "aho-corasick", "bstr", "log", - "regex-automata 0.4.16", + "regex-automata 0.4.18", "regex-syntax 0.8.11", ] @@ -772,15 +772,15 @@ dependencies = [ [[package]] name = "ignore" -version = "0.4.30" +version = "0.4.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b009b6744c1445efd7244084e25e498636412effb6760b55067553baa925cc7" +checksum = "00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f" dependencies = [ "crossbeam-deque", "globset", "log", "memchr", - "regex-automata 0.4.16", + "regex-automata 0.4.18", "same-file", "walkdir", "winapi-util", @@ -803,7 +803,7 @@ checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -849,9 +849,9 @@ dependencies = [ [[package]] name = "js-sys" -version = "0.3.103" +version = "0.3.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102" +checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a" dependencies = [ "cfg-if", "futures-util", @@ -887,9 +887,9 @@ checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37" [[package]] name = "libc" -version = "0.2.186" +version = "0.2.189" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" [[package]] name = "linux-raw-sys" @@ -983,9 +983,9 @@ dependencies = [ [[package]] name = "num-integer" -version = "0.1.46" +version = "0.1.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" dependencies = [ "num-traits", ] @@ -1001,9 +1001,9 @@ dependencies = [ [[package]] name = "object" -version = "0.37.3" +version = "0.39.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +checksum = "2e5a6c098c7a3b6547378093f5cc30bc54fd361ce711e05293a5cc589562739b" dependencies = [ "memchr", ] @@ -1045,7 +1045,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -1068,9 +1068,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "pkg-config" -version = "0.3.33" +version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" [[package]] name = "ppv-lite86" @@ -1088,7 +1088,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn", + "syn 2.0.119", ] [[package]] @@ -1113,18 +1113,18 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.106" +version = "1.0.107" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" dependencies = [ "unicode-ident", ] [[package]] name = "psm" -version = "0.1.31" +version = "0.1.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea" +checksum = "4dcd034599e63b970727f70d79e02d62390a4a84f7c6b827c27c46d5ac3fa622" dependencies = [ "ar_archive_writer", "cc", @@ -1132,9 +1132,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.46" +version = "1.0.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" dependencies = [ "proc-macro2", ] @@ -1194,9 +1194,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.16" +version = "0.4.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fcfdb36bda0c880c5931cdc7a2bcdc8ba4556847b9d912bca70bc94708711ad" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" dependencies = [ "aho-corasick", "memchr", @@ -1263,9 +1263,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.42" +version = "0.23.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c54fcab019b409d04215d3a17cb438fd7fbf192ee61461f20f4fe18704bc138" +checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06" dependencies = [ "aws-lc-rs", "log", @@ -1278,18 +1278,18 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.15.0" +version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "764899a24af3980067ee14bc143654f297b22eaebfe3c7b6b211920a5a59b046" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" dependencies = [ "zeroize", ] [[package]] name = "rustls-webpki" -version = "0.103.13" +version = "0.103.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e" +checksum = "0527518605e68109d875e248ea259b6758801cf165e4b2c2733ae3b51f12535a" dependencies = [ "aws-lc-rs", "ring", @@ -1358,9 +1358,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.228" +version = "1.0.229" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" dependencies = [ "serde_core", "serde_derive", @@ -1368,29 +1368,29 @@ dependencies = [ [[package]] name = "serde_core" -version = "1.0.228" +version = "1.0.229" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.228" +version = "1.0.229" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.3", ] [[package]] name = "serde_json" -version = "1.0.150" +version = "1.0.151" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" dependencies = [ "itoa", "memchr", @@ -1491,9 +1491,9 @@ checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "smplx-build" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55a9a38dc0d803acdeed6217cdf9c1b3ded9220796315a458f47572269abaf2f" +checksum = "f9f3e2235cc1bb20a5dda4bd32c9be665f39c95f1bcc62d7aa2a9adfc8fb670f" dependencies = [ "glob", "globwalk", @@ -1503,27 +1503,28 @@ dependencies = [ "quote", "serde", "simplicityhl", - "syn", + "syn 2.0.119", "thiserror", "toml", + "toml_edit", ] [[package]] name = "smplx-macros" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76e1091132a1f5157111920504e403fc8a4eb8a7814a376e4bd4c55a7fb6edff" +checksum = "03e1a764666ba1aada361499286710a0d5d7f1a0251d882a0843bb67ae5b7973" dependencies = [ "smplx-build", "smplx-test", - "syn", + "syn 2.0.119", ] [[package]] name = "smplx-regtest" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ccf7e3eade934e890bcee3558af658de46177dbd6a5dd0302bb1a64b7701bbe" +checksum = "f60a5ca5ccc0b531f4915f1d044c68b7ba3bc344e84ac019f539b2e488c8c8d7" dependencies = [ "electrsd", "hex", @@ -1537,9 +1538,9 @@ dependencies = [ [[package]] name = "smplx-sdk" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89d06536b493296672867c1a1ea8d67538c233af72624c18694ecb50691fcb74" +checksum = "940acb2e942bda24f3f27c3a387aabcf866dc16299746e79a58b47d091162f5d" dependencies = [ "bip39", "bitcoin_hashes", @@ -1557,9 +1558,9 @@ dependencies = [ [[package]] name = "smplx-std" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "834fd437c9394610ece857755d5967124a0b97c6837bf1170ae8deed38ba4d32" +checksum = "bcfa462d2e480d1fa6baa382d578501991fd19c3fb15ae5cdd44be362ef5e9ef" dependencies = [ "either", "serde", @@ -1571,9 +1572,9 @@ dependencies = [ [[package]] name = "smplx-test" -version = "0.0.8" +version = "0.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82bf119d89ca2b2ac992377912efe7dd1915e0aa6a193ca5383fb8a3da86594c" +checksum = "d76eab48bbf610aea049644b6aacffebbb194e59c663cd450b1f30a29ead19c1" dependencies = [ "electrsd", "proc-macro2", @@ -1582,16 +1583,16 @@ dependencies = [ "simplicityhl", "smplx-regtest", "smplx-sdk", - "syn", + "syn 2.0.119", "thiserror", "toml", ] [[package]] name = "stacker" -version = "0.1.24" +version = "0.1.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "640c8cdd92b6b12f5bcb1803ca3bbf5ab96e5e6b6b96b9ab77dabe9e880b3190" +checksum = "707f49d46706bacf8a2b00d51dace3f9de527c13eec3778f570c411f89e69967" dependencies = [ "cc", "cfg-if", @@ -1629,6 +1630,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "tap" version = "1.0.1" @@ -1650,22 +1662,22 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.18" +version = "2.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.18" +version = "2.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.3", ] [[package]] @@ -1725,14 +1737,15 @@ dependencies = [ "indexmap", "toml_datetime 1.1.1+spec-1.1.0", "toml_parser", + "toml_writer", "winnow 1.0.4", ] [[package]] name = "toml_parser" -version = "1.1.2+spec-1.1.0" +version = "1.1.3+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526" +checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56" dependencies = [ "winnow 1.0.4", ] @@ -1751,9 +1764,9 @@ checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" [[package]] name = "uint" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e" +checksum = "6f9227a75a5a540a464c832ad4a4195dbdbecd8787610a56262721fde6f04f90" dependencies = [ "byteorder", "crunchy", @@ -1824,9 +1837,9 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" [[package]] name = "wasm-bindgen" -version = "0.2.126" +version = "0.2.127" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4" +checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70" dependencies = [ "cfg-if", "once_cell", @@ -1837,9 +1850,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.126" +version = "0.2.127" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1" +checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -1847,31 +1860,31 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.126" +version = "0.2.127" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e" +checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284" dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn", + "syn 2.0.119", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.126" +version = "0.2.127" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24" +checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf" dependencies = [ "unicode-ident", ] [[package]] name = "webpki-roots" -version = "1.0.8" +version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf85cb06032201fa7c6f829d7db5a7e5aa45bcc0655327713065f6f0576731bf" +checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" dependencies = [ "rustls-pki-types", ] @@ -2020,22 +2033,22 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.54" +version = "0.8.56" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19" +checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.54" +version = "0.8.56" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5" +checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index d636ad8..25078a7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,7 @@ keywords = ["simplicity", "liquid", "elements", "smart-contracts"] categories = ["cryptography::cryptocurrencies"] [dependencies] -smplx-std = "0.0.8" +smplx-std = "0.0.9" [dev-dependencies] anyhow = { version = "1.0.101" }