Merge pull request #3 from CetusProtocol/hot-fix

Hot fix for forward compatibility in aptos

Author: CetusProtocol

aptos/sources/full_math_u128.move

@@ -1,30 +1,44 @@
 module integer_mate::full_math_u128 {
+    use integer_mate::u256;
+    use integer_mate::math_u128;
+
     public fun mul_div_floor(num1: u128, num2: u128, denom: u128): u128 {
-        let r = full_mul(num1, num2) / (denom as u256);
+        let r = full_mul_v2(num1, num2) / (denom as u256);
         (r as u128)
     }
 
     public fun mul_div_round(num1: u128, num2: u128, denom: u128): u128 {
-        let r = (full_mul(num1, num2) + ((denom as u256) >> 1)) / (denom as u256);
+        let r = (full_mul_v2(num1, num2) + ((denom as u256) >> 1)) / (denom as u256);
         (r as u128)
     }
 
     public fun mul_div_ceil(num1: u128, num2: u128, denom: u128): u128 {
-        let r = (full_mul(num1, num2) + ((denom as u256) - 1)) / (denom as u256);
+        let r = (full_mul_v2(num1, num2) + ((denom as u256) - 1)) / (denom as u256);
         (r as u128)
     }
 
     public fun mul_shr(num1: u128, num2: u128, shift: u8): u128 {
-        let product = full_mul(num1, num2) >> shift;
+        let product = full_mul_v2(num1, num2) >> shift;
         (product as u128)
     }
 
     public fun mul_shl(num1: u128, num2: u128, shift: u8): u128 {
-        let product = full_mul(num1, num2) << shift;
+        let product = full_mul_v2(num1, num2) << shift;
         (product as u128)
     }
 
-    public fun full_mul(num1: u128, num2: u128): u256 {
+    public fun full_mul(num1: u128, num2: u128): u256::U256 {
+        let (lo, hi) = math_u128::full_mul(num1, num2);
+        u256::new(
+            math_u128::lo(lo),
+            math_u128::hi(lo),
+            math_u128::lo(hi),
+            math_u128::hi(hi),
+        )
+    }
+
+    public fun full_mul_v2(num1: u128, num2: u128): u256 {
         (num1 as u256) * (num2 as u256)
     }
+
 }

aptos/sources/i128.move

@@ -1,8 +1,9 @@
 module integer_mate::i128 {
+    use std::error;
     use integer_mate::i64;
     use integer_mate::i32;
 
-    const EOverflow: u64 = 0;
+    const OVERFLOW: u64 = 0;
 
     const MIN_AS_U128: u128 = 1 << 127;
     const MAX_AS_U128: u128 = 0x7fffffffffffffffffffffffffffffff;
@@ -22,14 +23,14 @@ module integer_mate::i128 {
     }
 
     public fun from(v: u128): I128 {
-        assert!(v <= MAX_AS_U128, EOverflow);
+        assert!(v <= MAX_AS_U128, error::invalid_argument(OVERFLOW));
         I128 {
             bits: v
         }
     }
 
     public fun neg_from(v: u128): I128 {
-        assert!(v <= MIN_AS_U128, EOverflow);
+        assert!(v <= MIN_AS_U128, error::invalid_argument(OVERFLOW));
         if (v == 0) {
             I128 {
                 bits: v
@@ -66,7 +67,7 @@ module integer_mate::i128 {
     public fun add(num1: I128, num2: I128): I128 {
         let sum = wrapping_add(num1, num2);
         let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign(sum));
-        assert!(overflow == 0, EOverflow);
+        assert!(overflow == 0, error::invalid_argument(OVERFLOW));
         sum
     }
 
@@ -119,7 +120,7 @@ module integer_mate::i128 {
         if (sign(v) == 0) {
             v
         } else {
-            assert!(v.bits > MIN_AS_U128, EOverflow);
+            assert!(v.bits > MIN_AS_U128, error::invalid_argument(OVERFLOW));
             I128 {
                 bits: u128_neg(v.bits - 1)
             }

aptos/sources/i64.move

@@ -1,5 +1,7 @@
 module integer_mate::i64 {
-    const EOverflow: u64 = 0;
+    use std::error;
+
+    const OVERFLOW: u64 = 0;
 
     const MIN_AS_U64: u64 = 1 << 63;
     const MAX_AS_U64: u64 = 0x7fffffffffffffff;
@@ -25,14 +27,14 @@ module integer_mate::i64 {
     }
 
     public fun from(v: u64): I64 {
-        assert!(v <= MAX_AS_U64, EOverflow);
+        assert!(v <= MAX_AS_U64, error::invalid_argument(OVERFLOW));
         I64 {
             bits: v
         }
     }
 
     public fun neg_from(v: u64): I64 {
-        assert!(v <= MIN_AS_U64, EOverflow);
+        assert!(v <= MIN_AS_U64, error::invalid_argument(OVERFLOW));
         if (v == 0) {
             I64 {
                 bits: v
@@ -63,7 +65,7 @@ module integer_mate::i64 {
         let overflow = (sign(num1) & sign(num2) & u8_neg(sign(sum))) + (u8_neg(sign(num1)) & u8_neg(sign(num2)) & sign(
             sum
         ));
-        assert!(overflow == 0, EOverflow);
+        assert!(overflow == 0, error::invalid_argument(OVERFLOW));
         sum
     }
 
@@ -101,7 +103,7 @@ module integer_mate::i64 {
         if (sign(v) == 0) {
             v
         } else {
-            assert!(v.bits > MIN_AS_U64, EOverflow);
+            assert!(v.bits > MIN_AS_U64, error::invalid_argument(OVERFLOW));
             I64 {
                 bits: u64_neg(v.bits - 1)
             }

aptos/sources/u256.move

@@ -1,4 +1,5 @@
 module integer_mate::u256 {
+    use std::error;
     use integer_mate::math_u64;
     use integer_mate::math_u128;
 
@@ -17,7 +18,7 @@ module integer_mate::u256 {
 
     /// Total words in `U256` (64 * 4 = 256).
     const WORDS: u8 = 4;
-    
+
     struct U256 has copy, drop, store {
         n0: u64,
         n1: u64,
@@ -57,7 +58,7 @@ module integer_mate::u256 {
         let (sum1, carry1) = math_u64::carry_add(a.n1, b.n1, carry0);
         let (sum2, carry2) = math_u64::carry_add(a.n2, b.n2, carry1);
         let (sum3, carry3) = math_u64::carry_add(a.n3, b.n3, carry2);
-        assert!(carry3 == 0, OVERFLOW);
+        assert!(carry3 == 0, error::invalid_argument(OVERFLOW));
         U256 {
             n0: sum0,
             n1: sum1,
@@ -78,7 +79,7 @@ module integer_mate::u256 {
         let (t3, overflow_t3) = math_u64::overflowing_sub(a.n3, b.n3);
         let (r3, overflow_s3) = math_u64::overflowing_sub(t3, carry2); 
         let carry3 = if (overflow_t3 || overflow_s3) { 1 } else { 0 }; 
-        assert!(carry3 == 0, OVERFLOW);
+        assert!(carry3 == 0, error::invalid_argument(OVERFLOW));
         U256 {
             n0: r0,
             n1: r1,
@@ -115,7 +116,6 @@ module integer_mate::u256 {
         result
     }
 
-    // TODO: OPT
     public fun div_mod(a: U256, b: U256): (U256, U256) {
         let ret = zero();
         let remainer = a;
@@ -160,12 +160,12 @@ module integer_mate::u256 {
     }
 
     public fun as_u128(n: U256): u128 {
-        assert!(n.n3 == 0 && n.n2 == 0, OVERFLOW);
+        assert!(n.n3 == 0 && n.n2 == 0, error::invalid_argument(OVERFLOW));
         math_u128::from_lo_hi(n.n0, n.n1)
     }
 
     public fun as_u64(n: U256): u64 {
-        assert!(n.n3 == 0 && n.n2 == 0 && n.n1 == 0, OVERFLOW);
+        assert!(n.n3 == 0 && n.n2 == 0 && n.n1 == 0, error::invalid_argument(OVERFLOW));
         n.n0
     }
 
@@ -293,8 +293,7 @@ module integer_mate::u256 {
     public fun checked_div_round(num: U256, denom: U256, round_up: bool): U256 {
         let (q, r) = div_mod(num, denom);
         if (round_up && gt(r, zero())) {
-            q.n0 = q.n0 + 1;
-            //return add(q, from(1))
+            return add(q, from(1))
         };
         q
     }
@@ -412,16 +411,15 @@ module integer_mate::u256 {
 
     #[test]
     fun test_add() {
-        add(from(1000), from(1000));
-        // let s = add(new(10, 10, 10, 10), new(10, 10, 10, 10));
-        // assert!(s.n0 == 20 && s.n1 == 20 && s.n2 == 20 && s.n3 == 20, 0);
-        //
-        // let s = add(from(0xffffffffffffffffffffffffffffffff), from(0xffffffffffffffffffffffffffffffff));
-        // assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 1 && s.n3 == 0, 0);
-        //
-        // let max = MAX_U64;
-        // let s = add(new(max, max, max, 10), new(max, max, max, 10));
-        // assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 18446744073709551615  && s.n3 == 21, 0);
+        let s = add(new(10, 10, 10, 10), new(10, 10, 10, 10));
+        assert!(s.n0 == 20 && s.n1 == 20 && s.n2 == 20 && s.n3 == 20, 0);
+
+        let s = add(from(0xffffffffffffffffffffffffffffffff), from(0xffffffffffffffffffffffffffffffff));
+        assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 1 && s.n3 == 0, 0);
+
+        let max = MAX_U64;
+        let s = add(new(max, max, max, 10), new(max, max, max, 10));
+        assert!(s.n0 == 18446744073709551614 && s.n1 == 18446744073709551615 && s.n2 == 18446744073709551615  && s.n3 == 21, 0);
     }
 
     #[test]
@@ -595,14 +593,4 @@ module integer_mate::u256 {
         //assert!(eq(checked_div_round(from(MAX_U128), from((MAX_U64 as u128)), true), from((MAX_U128 / 10) + 1)) == true, 0);
         //assert!(eq(checked_div_round(from(MAX_U128), from((MAX_U64 as u128)), false), from((MAX_U128 / 10))) == true, 0);
     }
-
-    #[test]
-    fun test_div_round() {
-        checked_div_round(from(1000000000000000000000000000), from(3), true);
-    }
-
-    #[test]
-    fun test_2_div() {
-        div_mod(from(1), from(1));
-    }
 }