Merge pull request #118 from zeroqn/feat-change-ckb-decimal-to-18

BREAKING CHANGE: change ckb decimal to 18

Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
 members = [
   "tests",
+  "c-uint256-tests",
 ]

c-uint256-tests/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "c-uint256-tests"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cty = "0.2"
+
+[dev-dependencies]
+proptest = "1.0"
+primitive-types = { version = "0.10", default-features = false, features = [ "impl-serde", "impl-rlp" ] }
+
+[build-dependencies]
+cc = "1.0"

c-uint256-tests/build.rs

@@ -0,0 +1,20 @@
+fn main() {
+    let mut build = cc::Build::new();
+
+    // building
+    build
+        .file("../c/rust-binding/uint256_wrapper.c")
+        .static_flag(true)
+        .flag("-O3")
+        .flag("-Wl,-static")
+        .flag("-Wl,--gc-sections")
+        .include("../c/")
+        .flag("-Wall")
+        .flag("-Werror")
+        .flag("-Wno-unused-parameter")
+        .flag("-Wno-nonnull")
+        .flag("-Wno-nonnull-compare")
+        .flag("-Wno-unused-function")
+        .define("__SHARED_LIBRARY__", None)
+        .compile("c-uint256.a");
+}

c-uint256-tests/loop_proptest

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+export PROPTEST_CASES=100000
+
+counter=1
+while :
+do
+    echo "$counter round"
+    cargo test
+    ((counter++))
+done

c-uint256-tests/src/bindings.rs

@@ -0,0 +1,168 @@
+/* automatically generated by rust-bindgen 0.59.2 */
+
+pub const true_: u32 = 1;
+pub const false_: u32 = 0;
+pub const INT8_MIN: i32 = -128;
+pub const INT16_MIN: i32 = -32768;
+pub const INT32_MIN: i32 = -2147483648;
+pub const INT64_MIN: i64 = -9223372036854775808;
+pub const INT8_MAX: u32 = 127;
+pub const INT16_MAX: u32 = 32767;
+pub const INT32_MAX: u32 = 2147483647;
+pub const INT64_MAX: u64 = 9223372036854775807;
+pub const UINT8_MAX: u32 = 255;
+pub const UINT16_MAX: u32 = 65535;
+pub const UINT32_MAX: u32 = 4294967295;
+pub const UINT64_MAX: i32 = -1;
+pub const SIZE_MAX: i32 = -1;
+pub type size_t = ::std::os::raw::c_ulong;
+pub type ssize_t = ::std::os::raw::c_long;
+extern "C" {
+    pub fn memset(
+        dest: *mut ::std::os::raw::c_void,
+        c: ::std::os::raw::c_int,
+        n: ::std::os::raw::c_ulong,
+    ) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn memcpy(
+        dest: *mut ::std::os::raw::c_void,
+        src: *const ::std::os::raw::c_void,
+        n: ::std::os::raw::c_ulong,
+    ) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn memcmp(
+        vl: *const ::std::os::raw::c_void,
+        vr: *const ::std::os::raw::c_void,
+        n: ::std::os::raw::c_ulong,
+    ) -> ::std::os::raw::c_int;
+}
+pub type WT = size_t;
+extern "C" {
+    pub fn memmove(
+        dest: *mut ::std::os::raw::c_void,
+        src: *const ::std::os::raw::c_void,
+        n: ::std::os::raw::c_ulong,
+    ) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn strcpy(
+        d: *mut ::std::os::raw::c_char,
+        s: *const ::std::os::raw::c_char,
+    ) -> *mut ::std::os::raw::c_char;
+}
+extern "C" {
+    pub fn strlen(s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
+}
+extern "C" {
+    pub fn strcmp(
+        l: *const ::std::os::raw::c_char,
+        r: *const ::std::os::raw::c_char,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn malloc(size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn free(ptr: *mut ::std::os::raw::c_void);
+}
+extern "C" {
+    pub fn calloc(
+        nmemb: ::std::os::raw::c_ulong,
+        size: ::std::os::raw::c_ulong,
+    ) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn realloc(
+        ptr: *mut ::std::os::raw::c_void,
+        size: ::std::os::raw::c_ulong,
+    ) -> *mut ::std::os::raw::c_void;
+}
+pub type cmpfun = ::std::option::Option<
+    unsafe extern "C" fn(
+        arg1: *const ::std::os::raw::c_void,
+        arg2: *const ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int,
+>;
+extern "C" {
+    pub fn qsort(base: *mut ::std::os::raw::c_void, nel: size_t, width: size_t, cmp: cmpfun);
+}
+extern "C" {
+    pub fn bsearch(
+        key: *const ::std::os::raw::c_void,
+        base: *const ::std::os::raw::c_void,
+        nel: size_t,
+        width: size_t,
+        cmp: ::std::option::Option<
+            unsafe extern "C" fn(
+                arg1: *const ::std::os::raw::c_void,
+                arg2: *const ::std::os::raw::c_void,
+            ) -> ::std::os::raw::c_int,
+        >,
+    ) -> *mut ::std::os::raw::c_void;
+}
+extern "C" {
+    pub fn printf(format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn _start();
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct uint256_t {
+    pub array: [u32; 8usize],
+}
+#[test]
+fn bindgen_test_layout_uint256_t() {
+    assert_eq!(
+        ::std::mem::size_of::<uint256_t>(),
+        32usize,
+        concat!("Size of: ", stringify!(uint256_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<uint256_t>(),
+        4usize,
+        concat!("Alignment of ", stringify!(uint256_t))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<uint256_t>())).array as *const _ as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(uint256_t),
+            "::",
+            stringify!(array)
+        )
+    );
+}
+extern "C" {
+    pub fn gw_uint256_zero(num: *mut uint256_t);
+}
+extern "C" {
+    pub fn gw_uint256_one(num: *mut uint256_t);
+}
+extern "C" {
+    pub fn gw_uint256_max(num: *mut uint256_t);
+}
+extern "C" {
+    pub fn gw_uint256_overflow_add(
+        a: uint256_t,
+        b: uint256_t,
+        sum: *mut uint256_t,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn gw_uint256_underflow_sub(
+        a: uint256_t,
+        b: uint256_t,
+        rem: *mut uint256_t,
+    ) -> ::std::os::raw::c_int;
+}
+pub const GW_UINT256_SMALLER: ::std::os::raw::c_int = -1;
+pub const GW_UINT256_EQUAL: ::std::os::raw::c_int = 0;
+pub const GW_UINT256_LARGER: ::std::os::raw::c_int = 1;
+pub type _bindgen_ty_1 = ::std::os::raw::c_int;
+extern "C" {
+    pub fn gw_uint256_cmp(a: uint256_t, b: uint256_t) -> ::std::os::raw::c_int;
+}

c-uint256-tests/src/lib.rs

@@ -0,0 +1,162 @@
+use std::cmp::Ordering;
+
+use self::bindings::{
+    gw_uint256_cmp, gw_uint256_one, gw_uint256_overflow_add, gw_uint256_underflow_sub, uint256_t,
+    GW_UINT256_EQUAL, GW_UINT256_LARGER, GW_UINT256_SMALLER,
+};
+
+// deref_nullptr in test code `fn bindgen_test_layout_uint256_t()`.
+#[allow(dead_code)]
+#[allow(non_camel_case_types)]
+#[allow(non_upper_case_globals)]
+#[allow(deref_nullptr)]
+mod bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct U256(uint256_t);
+
+impl U256 {
+    pub fn from_le_bytes(bytes: [u8; 32]) -> Self {
+        let mut array = [0u32; 8];
+        for i in 0..8 {
+            let start = i * 4;
+            let end = i * 4 + 4;
+            let u32_val = u32::from_le_bytes(bytes[start..end].try_into().unwrap());
+            array[i] = u32_val;
+        }
+        U256(uint256_t { array })
+    }
+
+    pub fn to_le_bytes(&self) -> [u8; 32] {
+        let mut bytes = [0u8; 32];
+        for i in 0..8 {
+            let u32_val = self.0.array[i];
+            let start = i * 4;
+            let end = i * 4 + 4;
+            bytes[start..end].copy_from_slice(&u32_val.to_le_bytes());
+        }
+
+        bytes
+    }
+
+    pub fn zero() -> Self {
+        U256(uint256_t { array: [0u32; 8] })
+    }
+
+    pub fn one() -> Self {
+        let mut val = Self::zero();
+        unsafe { gw_uint256_one(&mut val.0) };
+
+        val
+    }
+
+    pub fn checked_add(&self, other: U256) -> Option<U256> {
+        let mut sum = U256::zero();
+        match unsafe { gw_uint256_overflow_add(self.0, other.0, &mut sum.0) } {
+            0 => Some(sum),
+            _err => None,
+        }
+    }
+
+    pub fn checked_sub(&self, other: U256) -> Option<U256> {
+        let mut rem = U256::zero();
+        match unsafe { gw_uint256_underflow_sub(self.0, other.0, &mut rem.0) } {
+            0 => Some(rem),
+            _err => None,
+        }
+    }
+}
+
+impl PartialOrd for U256 {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match unsafe { gw_uint256_cmp(self.0, other.0) } {
+            GW_UINT256_SMALLER => Some(Ordering::Less),
+            GW_UINT256_EQUAL => Some(Ordering::Equal),
+            GW_UINT256_LARGER => Some(Ordering::Greater),
+            _ => None,
+        }
+    }
+}
+
+impl Ord for U256 {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::U256 as CU256;
+    use primitive_types::U256 as PU256;
+    use proptest::prelude::*;
+
+    impl PartialEq<PU256> for CU256 {
+        fn eq(&self, other: &PU256) -> bool {
+            let mut other_le_bytes = [0u8; 32];
+            other.to_little_endian(&mut other_le_bytes);
+
+            self.to_le_bytes() == other_le_bytes
+        }
+    }
+
+    impl CU256 {
+        fn into_pu256(self) -> PU256 {
+            PU256::from_little_endian(&self.to_le_bytes())
+        }
+    }
+
+    #[test]
+    fn test_c_uint256_one() {
+        let one = CU256::one();
+        assert_eq!(one.checked_sub(one), Some(CU256::zero()));
+
+        let p_one = PU256::one();
+        assert_eq!(one, p_one);
+    }
+
+    proptest! {
+        #[test]
+        fn test_c_uint256_checked_add(
+            a in prop::array::uniform32(any::<u8>()),
+            b in prop::array::uniform32(any::<u8>())
+        ) {
+            let ca = CU256::from_le_bytes(a);
+            let cb = CU256::from_le_bytes(b);
+            let csum = ca.checked_add(cb);
+
+            let pa = PU256::from_little_endian(&a);
+            let pb = PU256::from_little_endian(&b);
+            let psum = pa.checked_add(pb);
+            prop_assert_eq!(csum.map(CU256::into_pu256), psum);
+        }
+
+        #[test]
+        fn test_c_uint256_checked_sub(
+            a in prop::array::uniform32(any::<u8>()),
+            b in prop::array::uniform32(any::<u8>())
+        ) {
+            let ca = CU256::from_le_bytes(a);
+            let cb = CU256::from_le_bytes(b);
+            let crem = ca.checked_sub(cb);
+
+            let pa = PU256::from_little_endian(&a);
+            let pb = PU256::from_little_endian(&b);
+            let prem = pa.checked_sub(pb);
+            prop_assert_eq!(crem.map(CU256::into_pu256), prem);
+        }
+
+        #[test]
+        fn test_c_uint256_cmp(
+            a in prop::array::uniform32(any::<u8>()),
+            b in prop::array::uniform32(any::<u8>())
+        ) {
+            let ca = CU256::from_le_bytes(a);
+            let cb = CU256::from_le_bytes(b);
+
+            let pa = PU256::from_little_endian(&a);
+            let pb = PU256::from_little_endian(&b);
+
+            prop_assert_eq!(ca > cb, pa > pb);
+        }
+    }
+}