From 0146520312b2a807750f816d620e39aa5f4e0a4d Mon Sep 17 00:00:00 2001
From: JChoy <jchoyeclipse@gmail.com>
Date: Wed, 19 Jun 2024 12:32:03 +0900
Subject: [PATCH] fix: fix orderId bugs

---
 src/lib.cairo                |  3 +-
 src/libraries/order_id.cairo | 64 ++++++++++++++++++++----------------
 2 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/src/lib.cairo b/src/lib.cairo
index 341e047..7e82864 100644
--- a/src/lib.cairo
+++ b/src/lib.cairo
@@ -1,7 +1,8 @@
 pub mod libraries {
-    pub mod lockers;
     pub mod currency_delta;
     pub mod fee_policy;
+    pub mod lockers;
+    pub mod order_id;
     pub mod tick;
 }
 
diff --git a/src/libraries/order_id.cairo b/src/libraries/order_id.cairo
index 64a4a0a..c231f27 100644
--- a/src/libraries/order_id.cairo
+++ b/src/libraries/order_id.cairo
@@ -1,39 +1,42 @@
 use starknet::storage_access::{StorePacking};
 
-const MASK_BOOK_ID: u256 = consteval_int!(2 * *192);
-const MASK_TICK: u256 = consteval_int!(2 * *32);
-const MASK_INDEX: u256 = consteval_int!(2 * *40);
-
-const TWO_POW_72: u256 = consteval_int!(2 * *72);
-const TWO_POW_40: u256 = consteval_int!(2 * *40);
+const TWO_POW_192: u256 = 0x1000000000000000000000000000000000000000000000000; // 2**192
+const TWO_POW_64: u256 = 0x10000000000000000; // 2**64
+const TWO_POW_40: u64 = 0x10000000000; // 2**40
 
 #[derive(Copy, Drop, Serde, Debug)]
 pub struct OrderId {
-    pub book_id: u256, // u192
-    pub tick: i32, // u32
+    pub book_id: felt252, // u192
+    pub tick: u32, // todo: change to Tick struct
     pub index: u64, // u40
 }
 
 #[generate_trait]
 impl OrderIdImpl of OrderIdTrait {
-    fn encode(self: OrderId) -> u256 {
-        assert(self.book_id < MASK_BOOK_ID, "book_id overflow");
-        assert(self.tick < MASK_TICK, "tick overflow");
-        assert(self.index < MASK_INDEX, "index overflow");
-        return self.book_id * TWO_POW_72 + self.tick * TWO_POW_40 + self.index;
+    fn encode(self: OrderId) -> felt252 {
+        assert(self.book_id.into() < TWO_POW_192, 'book_id overflow');
+        assert(self.index < TWO_POW_40, 'index overflow');
+        return self.book_id.try_into().unwrap() * TWO_POW_64.try_into().unwrap()
+            + self.tick.into() * TWO_POW_40.try_into().unwrap()
+            + self.index.into();
     }
 }
 
-impl OrderIdStoragePacking of StoragePacking<OrderId, u256> {
-    fn pack(value: OrderId) -> u256 {
+impl OrderIdStoragePacking of StorePacking<OrderId, felt252> {
+    fn pack(value: OrderId) -> felt252 {
         value.encode()
     }
 
-    fn unpack(value: u256) -> OrderId {
-        let book_id = value / TWO_POW_72;
-        let tick = (value % TWO_POW_72) / TWO_POW_40;
-        let index = value % TWO_POW_40;
-        OrderId { book_id, tick, index }
+    fn unpack(value: felt252) -> OrderId {
+        let casted_value: u256 = value.into();
+        let book_id: u256 = casted_value / TWO_POW_64.into();
+        let tick_felt252: felt252 = (casted_value % TWO_POW_64.into() / TWO_POW_40.into())
+            .try_into()
+            .unwrap();
+        let index: u64 = (casted_value % TWO_POW_40.into()).try_into().unwrap();
+        OrderId {
+            book_id: book_id.try_into().unwrap(), tick: tick_felt252.try_into().unwrap(), index
+        }
     }
 }
 
@@ -41,31 +44,34 @@ impl OrderIdStoragePacking of StoragePacking<OrderId, u256> {
 mod tests {
     use super::OrderId;
     use super::OrderIdImpl;
-    use super::StoragePacking;
+    use super::StorePacking;
+
+    // todo delete this
+    const TWO_POW_24: u32 = 0x1000000; // 2**24
 
     #[test]
     fn encode() {
         let order_id = OrderId { book_id: 1, tick: 2, index: 3 };
         let encoded = order_id.encode();
-        assert_eq!(encoded, 0x10000020000000003_u256);
+        assert_eq!(encoded, 0x10000020000000003_felt252);
 
-        let order_id = OrderId { book_id: 1, tick: -2, index: 3 };
+        let order_id = OrderId { book_id: 1, tick: TWO_POW_24 - 2, index: 3 };
         let encoded = order_id.encode();
-        assert_eq!(encoded, 0x1fffffe0000000003_u256);
+        assert_eq!(encoded, 0x1fffffe0000000003_felt252);
     }
 
     #[test]
     fn unpack() {
-        let encoded = 0x10000020000000003_u256;
-        let order_id = OrderId::unpack(encoded);
+        let encoded = 0x10000020000000003_felt252;
+        let order_id: OrderId = StorePacking::unpack(encoded);
         assert_eq!(order_id.book_id, 1);
         assert_eq!(order_id.tick, 2);
         assert_eq!(order_id.index, 3);
 
-        let encoded = 0x1fffffe0000000003_u256;
-        let order_id = OrderId::unpack(encoded);
+        let encoded = 0x1fffffe0000000003_felt252;
+        let order_id: OrderId = StorePacking::unpack(encoded);
         assert_eq!(order_id.book_id, 1);
-        assert_eq!(order_id.tick, -2);
+        assert_eq!(order_id.tick, TWO_POW_24 - 2);
         assert_eq!(order_id.index, 3);
     }
 }