tiny optimization

HerodotusDev · Aug 29, 2023 · f4413e7 · f4413e7
1 parent 8c1d2aa
commit f4413e7
Show file tree

Hide file tree

Showing 2 changed files with 64 additions and 64 deletions.
diff --git a/src/encoding/rlp_word64.cairo b/src/encoding/rlp_word64.cairo
@@ -51,10 +51,10 @@ enum RLPItemWord64 {
 // @param input RLP encoded bytes
 // @return Result with RLPItem and size of the decoded item
 fn rlp_decode_word64(input: Words64) -> Result<(RLPItemWord64, usize), felt252> {
-    let prefix: u8 = (*input.at(0) & 0xff).try_into().unwrap();
+    let prefix: u32  = (*input.at(0) & 0xff).try_into().unwrap();
 
     // Unwrap is impossible to panic here
-    let rlp_type = RLPTypeTrait::from_byte(prefix).unwrap();
+    let rlp_type = RLPTypeTrait::from_byte(prefix.try_into().unwrap()).unwrap();
     match rlp_type {
         RLPType::String(()) => {
             let mut arr = array![prefix.into()];
@@ -67,7 +67,7 @@ fn rlp_decode_word64(input: Words64) -> Result<(RLPItemWord64, usize), felt252>
             Result::Ok((RLPItemWord64::Bytes(res), 1 + len))
         },
         RLPType::StringLong(()) => {
-            let len_len = prefix.into() - 0xb7;
+            let len_len = prefix - 0xb7;
             let len_span = input.slice_le(6, len_len);
             // Enough to store 4.29 GB (fits in u32)
             assert(len_span.len() == 1 && *len_span.at(0) <= 0xffffffff, 'Len of len too big');
@@ -81,13 +81,13 @@ fn rlp_decode_word64(input: Words64) -> Result<(RLPItemWord64, usize), felt252>
             Result::Ok((RLPItemWord64::Bytes(res), 1 + len_len + len))
         },
         RLPType::ListShort(()) => {
-            let mut len = prefix.into() - 0xc0;
+            let mut len = prefix - 0xc0;
             let mut in = input.slice_le(6, len);
             let res = rlp_decode_list_word64(ref in, len);
             Result::Ok((RLPItemWord64::List(res), 1 + len))
         },
         RLPType::ListLong(()) => {
-            let len_len = prefix.into() - 0xf7;
+            let len_len = prefix - 0xf7;
             let len_span = input.slice_le(6, len_len);
             // Enough to store 4.29 GB (fits in u32)
             assert(len_span.len() == 1 && *len_span.at(0) <= 0xffffffff, 'Len of len too big');

diff --git a/src/utils/types/words64.cairo b/src/utils/types/words64.cairo
@@ -22,7 +22,7 @@ impl Words64Impl of Words64Trait {
 
         let word_offset_bits = word_offset_bytes * 8;
         let pow2_word_offset_bits = pow2(word_offset_bits);
-        let mask_second_word = left_shift_u64(1, word_offset_bits) - 1;
+        let mask_second_word = pow2_word_offset_bits - 1;
         let reverse_words_offset_bits = 64 - word_offset_bits;
 
         let mut pow2_reverse_words_offset_bits = 0;
@@ -91,6 +91,64 @@ impl Words64Impl of Words64Trait {
     }
 }
 
+fn left_shift_u64(num: u64, shift: usize) -> u64 {
+    num * pow2(shift)
+}
+
+fn right_shift_u64(num: u64, shift: usize) -> u64 {
+    num / pow2(shift)
+}
+
+fn bytes_used(val: u64) -> usize {
+    if val < 4294967296 { // 256^4
+        if val < 65536 { // 256^2
+            if val < 256 { // 256^1
+                if val == 0 {
+                    return 0;
+                } else {
+                    return 1;
+                };
+            }
+            return 2;
+        }
+        if val < 16777216 { // 256^3
+            return 3;
+        }
+        return 4;
+    } else {
+        if val < 281474976710656 { // 256^6
+            if val < 1099511627776 { // 256^5
+                return 5;
+            }
+            return 6;
+        }
+        if val < 72057594037927936 { // 256^7
+            return 7;
+        }
+        return 8;
+    }
+}
+
+fn reverse_endianness(input: u64, significant_bytes: Option<u64>) -> u64 {
+    let sb = match significant_bytes {
+        Option::Some(x) => x,
+        Option::None(()) => 56
+    };
+
+    let mut reverse = 0;
+    let mut i = 0;
+    loop {
+        if i == sb {
+            break reverse;
+        }
+
+        let r_shift = right_shift(input, (i * 8)) & 0xff;
+        reverse = reverse | left_shift(r_shift, (sb - i - 1) * 8);
+
+        i += 1;
+    }
+}
+
 fn pow2(pow: usize) -> u64 {
     if pow == 0 {
         return 0x1;
@@ -225,61 +283,3 @@ fn pow2(pow: usize) -> u64 {
     }
 }
 
-fn left_shift_u64(num: u64, shift: usize) -> u64 {
-    num * pow2(shift)
-}
-
-fn right_shift_u64(num: u64, shift: usize) -> u64 {
-    num / pow2(shift)
-}
-
-fn bytes_used(val: u64) -> usize {
-    if val < 4294967296 { // 256^4
-        if val < 65536 { // 256^2
-            if val < 256 { // 256^1
-                if val == 0 {
-                    return 0;
-                } else {
-                    return 1;
-                };
-            }
-            return 2;
-        }
-        if val < 16777216 { // 256^3
-            return 3;
-        }
-        return 4;
-    } else {
-        if val < 281474976710656 { // 256^6
-            if val < 1099511627776 { // 256^5
-                return 5;
-            }
-            return 6;
-        }
-        if val < 72057594037927936 { // 256^7
-            return 7;
-        }
-        return 8;
-    }
-}
-
-fn reverse_endianness(input: u64, significant_bytes: Option<u64>) -> u64 {
-    let sb = match significant_bytes {
-        Option::Some(x) => x,
-        Option::None(()) => 56
-    };
-
-    let mut reverse = 0;
-    let mut i = 0;
-    loop {
-        if i == sb {
-            break reverse;
-        }
-
-        let r_shift = right_shift(input, (i * 8)) & 0xff;
-        reverse = reverse | left_shift(r_shift, (sb - i - 1) * 8);
-
-        i += 1;
-    }
-}
-