Merge pull request #9 from pragma-org/jshy/num-bigint

Author: rvcas

Cargo.lock

@@ -16,11 +16,10 @@ bumpalo = { version = "3.16.0", features = ["collections"] }
 chumsky = { version = "=1.0.0-alpha.7", features = ["pratt"] }
 cryptoxide = "0.4.4"
 minicbor = { version = "0.25.1", features = ["std"] }
+num = "0.4.3"
+num-bigint = "0.4"
+num-integer = "0.1"
 once_cell = "1.20.2"
-rug = { version = "1.26.0", default-features = false, features = [
-    "integer",
-    "std",
-] }
 secp256k1 = "0.30.0"
 thiserror = "1.0.63"
 

crates/uplc/Cargo.toml

@@ -10,7 +10,7 @@ pub static SCALAR_PERIOD: Lazy<Integer> = Lazy::new(|| {
         0x00, 0x01,
     ];
 
-    Integer::from_digits(&bytes, rug::integer::Order::MsfBe)
+    Integer::from_bytes_be(num_bigint::Sign::Plus, &bytes)
 });
 
 pub const BLST_P1_COMPRESSED_SIZE: usize = 48;

crates/uplc/src/bls.rs

@@ -22,10 +22,10 @@ pub enum Constant<'a> {
     Bls12_381MlResult(&'a blst::blst_fp12),
 }
 
-pub type Integer = rug::Integer;
+pub type Integer = num::BigInt;
 
 pub fn integer(arena: &Bump) -> &mut Integer {
-    arena.alloc(Integer::new())
+    arena.alloc(Integer::default())
 }
 
 pub fn integer_from(arena: &Bump, i: i128) -> &mut Integer {

crates/uplc/src/constant.rs

@@ -1,6 +1,5 @@
 use bumpalo::collections::Vec as BumpVec;
 use minicbor::data::{IanaTag, Tag};
-use rug::ops::NegAssign;
 
 use crate::data::PlutusData;
 
@@ -73,13 +72,14 @@ impl<'a, 'b> minicbor::decode::Decode<'b, Ctx<'a>> for &'a PlutusData<'a> {
                             bytes.extend_from_slice(chunk);
                         }
 
-                        let integer = ctx
-                            .arena
-                            .alloc(rug::Integer::from_digits(&bytes, rug::integer::Order::Msf));
-
-                        if x == IanaTag::NegBignum {
-                            integer.neg_assign();
-                        }
+                        let integer = ctx.arena.alloc(num::BigInt::from_bytes_be(
+                            if x == IanaTag::PosBignum {
+                                num_bigint::Sign::Plus
+                            } else {
+                                num_bigint::Sign::Plus
+                            },
+                            &bytes,
+                        ));
 
                         Ok(PlutusData::integer(ctx.arena, integer))
                     }

crates/uplc/src/flat/data.rs

@@ -153,16 +153,16 @@ impl Encoder {
 
         loop {
             let temp: Integer = d.clone() % 128;
-            let mut w = temp.to_u8().unwrap();
+            let mut w: u8 = temp.try_into().unwrap();
 
             d >>= 7;
 
-            if d != 0 {
+            if d != Integer::ZERO {
                 w |= 128;
             }
             self.bits(8, w);
 
-            if d == 0 {
+            if d == Integer::ZERO {
                 break;
             }
         }

crates/uplc/src/flat/encode/encoder.rs

@@ -14,7 +14,7 @@ impl ZigZag for &Integer {
     type Zag = Integer;
 
     fn zigzag(self) -> Self::Zag {
-        if *self >= 0 {
+        if *self >= 0.into() {
             // For non-negative numbers, just multiply by 2 (left shift by 1)
             self.clone() << 1
         } else {
@@ -28,7 +28,7 @@ impl ZigZag for &Integer {
     }
 
     fn unzigzag(self) -> Self::Zag {
-        let temp: Integer = self.clone() & 1;
+        let temp: Integer = self.clone() & Integer::from(1);
 
         (self.clone() >> 1) ^ -(temp)
     }

crates/uplc/src/flat/zigzag.rs

@@ -1,4 +1,4 @@
-use rug::integer::BorrowInteger;
+use num::{BigUint, Zero};
 
 use crate::{
     binder::Eval,
@@ -11,27 +11,27 @@ pub const UNIT_EX_MEM: i64 = 1;
 pub const BOOL_EX_MEM: i64 = 1;
 
 pub fn integer_ex_mem(i: &Integer) -> i64 {
-    if *i == 0 {
+    if i.is_zero() {
         1
     } else {
-        (integer_log2(i.as_abs()) / 64) + 1
+        (integer_log2(i.magnitude()) / 64) + 1
     }
 }
 
-pub fn integer_log2(i: BorrowInteger<'_>) -> i64 {
+pub fn integer_log2(i: &BigUint) -> i64 {
     if i.is_zero() {
         return 0;
     }
 
-    (i.significant_bits() - 1) as i64
+    (i.bits() - 1) as i64
 }
 
 pub fn integer_log2_x(i: &Integer) -> i64 {
     if i.is_zero() {
         return 0;
     }
 
-    (i.significant_bits() - 1) as i64
+    (i.bits() - 1) as i64
 }
 
 pub fn byte_string_ex_mem(b: &[u8]) -> i64 {
@@ -129,76 +129,78 @@ pub fn ml_result_ex_mem() -> i64 {
 mod tests {
     use std::str::FromStr;
 
+    use crate::constant::Integer;
+
     use super::integer_log2;
 
     #[test]
     fn integer_log2_oracle() {
         // Values come from the Haskell implementation
-        assert_eq!(integer_log2(rug::Integer::from(0).as_abs()), 0);
-        assert_eq!(integer_log2(rug::Integer::from(1).as_abs()), 0);
-        assert_eq!(integer_log2(rug::Integer::from(42).as_abs()), 5);
+        assert_eq!(integer_log2(Integer::ZERO.magnitude()), 0);
+        assert_eq!(integer_log2(Integer::from(1).magnitude()), 0);
+        assert_eq!(integer_log2(Integer::from(42).magnitude()), 5);
 
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("18446744073709551615")
+                Integer::from_str("18446744073709551615")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             63
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("999999999999999999999999999999")
+                Integer::from_str("999999999999999999999999999999")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             99
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("170141183460469231731687303715884105726")
+                Integer::from_str("170141183460469231731687303715884105726")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             126
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("170141183460469231731687303715884105727")
+                Integer::from_str("170141183460469231731687303715884105727")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             126
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("170141183460469231731687303715884105728")
+                Integer::from_str("170141183460469231731687303715884105728")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             127
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("340282366920938463463374607431768211458")
+                Integer::from_str("340282366920938463463374607431768211458")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             128
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("999999999999999999999999999999999999999999")
+                Integer::from_str("999999999999999999999999999999999999999999")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             139
         );
         assert_eq!(
             integer_log2(
-                rug::Integer::from_str("999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
+                Integer::from_str("999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
                     .unwrap()
-                    .as_abs()
+                    .magnitude()
             ),
             279
         );