Implementation of rlp::decode()

crates/utils/src/helpers.cairo

@@ -7,6 +7,7 @@ use utils::constants::{
     POW_256_16,
 };
 use keccak::u128_split;
+use utils::math::Bitshift;
 
 
 /// Ceils a number of bits to the next word (32 bytes)
@@ -504,6 +505,34 @@ impl SpanExtension<T, +Copy<T>, +Drop<T>> of SpanExtensionTrait<T> {
     }
 }
 
+impl SpanU8TryIntoU256 of TryInto<Span<u8>, u256> {
+    fn try_into(self: Span<u8>) -> Option<u256> {
+        let len = self.len();
+        if len > 32 {
+            return Option::None(());
+        }
+
+        if self.is_empty() {
+            return Option::Some(0);
+        }
+
+        let offset = len.into() - 1;
+        let mut result: u256 = 0;
+        let mut i: usize = 0;
+        loop {
+            if i >= len {
+                break ();
+            }
+            let byte: u256 = (*self.at(i)).into();
+            result += Bitshift::shl(byte, 8 * (offset - i.into()));
+
+            i += 1;
+        };
+
+        Option::Some(result)
+    }
+}
+
 
 #[generate_trait]
 impl U256Impl of U256Trait {

crates/utils/src/math.cairo

@@ -1,6 +1,7 @@
 use integer::{
     u256, u256_overflow_mul, u256_overflowing_add, u512, BoundedInt, u128_overflowing_mul
 };
+use math::Oneable;
 
 trait Exponentiation<T> {
     /// Raise a number to a power.
@@ -231,3 +232,28 @@ impl U128WrappingBitshiftImpl of WrappingBitshift<u128> {
     }
 }
 
+fn pow<
+    T,
+    impl TZeroable: Zeroable<T>,
+    impl TSub: Sub<T>,
+    impl TMul: Mul<T>,
+    impl TOneable: Oneable<T>,
+    impl TCopy: Copy<T>,
+    impl TDrop: Drop<T>
+>(
+    base: T, mut exp: T
+) -> T {
+    if exp.is_zero() {
+        TOneable::one()
+    } else {
+        base * pow(base, exp - TOneable::one())
+    }
+}
+
+fn pow_felt252(base: felt252, exp: felt252) -> felt252 {
+    if exp == 0 {
+        1
+    } else {
+        base * pow_felt252(base, exp - 1)
+    }
+}

crates/utils/src/rlp.cairo

@@ -1,7 +1,158 @@
-// Reproduce the original rlp.cairo from https://github.com/kkrt-labs/kakarot/blob/7ec7a96074394ddb592a2b6fbea279c6c5cb25a6/src/utils/rlp.cairo#L18
-// By using new Cairo idiomatic ways: Traits, Struct and impl blocks.
+use result::ResultTrait;
+use option::OptionTrait;
+use array::{Array, ArrayTrait, Span, SpanTrait};
+use clone::Clone;
+use traits::{Into, TryInto};
+use utils::helpers::SpanU8TryIntoU256;
 
-// We can reuse https://github.com/HerodotusDev/cairo-lib/blob/main/src/encoding/rlp.cairo 
-// Check before reusing that it works soundly
+// @notice Enum with all possible RLP types
+#[derive(Drop, PartialEq)]
+enum RLPType {
+    String: (),
+    StringShort: (),
+    StringLong: (),
+    ListShort: (),
+    ListLong: (),
+}
 
+#[generate_trait]
+impl RLPTypeImpl of RLPTypeTrait {
+    // @notice Returns RLPType from the leading byte
+    // @param byte Leading byte
+    // @return Result with RLPType
+    fn from_byte(byte: u8) -> Result<RLPType, felt252> {
+        if byte <= 0x7f {
+            Result::Ok(RLPType::String(()))
+        } else if byte <= 0xb7 {
+            Result::Ok(RLPType::StringShort(()))
+        } else if byte <= 0xbf {
+            Result::Ok(RLPType::StringLong(()))
+        } else if byte <= 0xf7 {
+            Result::Ok(RLPType::ListShort(()))
+        } else if byte <= 0xff {
+            Result::Ok(RLPType::ListLong(()))
+        } else {
+            Result::Err('Invalid byte')
+        }
+    }
+}
 
+// @notice Represent a RLP item
+#[derive(Drop)]
+enum RLPItem {
+    Bytes: Span<u8>,
+    // Should be Span<RLPItem> to allow for any depth/recursion, not yet supported by the compiler
+    List: Span<Span<u8>>
+}
+
+// @notice RLP decodes a rlp encoded byte array
+// @param input RLP encoded bytes
+// @return Result with RLPItem and size of the decoded item
+fn rlp_decode(input: Span<u8>) -> Result<(RLPItem, usize), felt252> {
+    let prefix = *input.at(0);
+
+    // Unwrap is impossible to panic here
+    let rlp_type = RLPTypeTrait::from_byte(prefix).unwrap();
+    match rlp_type {
+        RLPType::String(()) => {
+            let mut arr = array![prefix];
+            Result::Ok((RLPItem::Bytes(arr.span()), 1))
+        },
+        RLPType::StringShort(()) => {
+            let len = prefix.into() - 0x80;
+            let res = input.slice(1, len);
+
+            Result::Ok((RLPItem::Bytes(res), 1 + len))
+        },
+        RLPType::StringLong(()) => {
+            let len_len = prefix.into() - 0xb7;
+            let len_span = input.slice(1, len_len);
+
+            // Bytes => u256 => u32
+            let len256: u256 = len_span.try_into().unwrap();
+            let len: u32 = len256.try_into().unwrap();
+            let res = input.slice(1 + len_len, len);
+
+            Result::Ok((RLPItem::Bytes(res), 1 + len_len + len))
+        },
+        RLPType::ListShort(()) => {
+            let len = prefix.into() - 0xc0;
+            let mut in = input.slice(1, len);
+            let res = rlp_decode_list(ref in);
+            Result::Ok((RLPItem::List(res), 1 + len))
+        },
+        RLPType::ListLong(()) => {
+            let len_len = prefix.into() - 0xf7;
+            let len_span = input.slice(1, len_len);
+
+            // Bytes => u256 => u32
+            let len256: u256 = len_span.try_into().unwrap();
+            let len: u32 = len256.try_into().unwrap();
+            let mut in = input.slice(1 + len_len, len);
+            let res = rlp_decode_list(ref in);
+            Result::Ok((RLPItem::List(res), 1 + len_len + len))
+        }
+    }
+}
+
+fn rlp_decode_list(ref input: Span<u8>) -> Span<Span<u8>> {
+    let mut i = 0;
+    let len = input.len();
+    let mut output = ArrayTrait::new();
+
+    loop {
+        if i >= len {
+            break ();
+        }
+
+        let (decoded, decoded_len) = rlp_decode(input).unwrap();
+        match decoded {
+            RLPItem::Bytes(b) => {
+                output.append(b);
+                input = input.slice(decoded_len, input.len() - decoded_len);
+            },
+            RLPItem::List(_) => { panic_with_felt252('Recursive list not supported'); }
+        }
+        i += decoded_len;
+    };
+    output.span()
+}
+
+impl RLPItemPartialEq of PartialEq<RLPItem> {
+    fn eq(lhs: @RLPItem, rhs: @RLPItem) -> bool {
+        match lhs {
+            RLPItem::Bytes(b) => {
+                match rhs {
+                    RLPItem::Bytes(b2) => { b == b2 },
+                    RLPItem::List(_) => false
+                }
+            },
+            RLPItem::List(l) => {
+                match rhs {
+                    RLPItem::Bytes(_) => false,
+                    RLPItem::List(l2) => {
+                        let len_l = (*l).len();
+                        if len_l != (*l2).len() {
+                            return false;
+                        }
+                        let mut i: usize = 0;
+                        loop {
+                            if i >= len_l {
+                                break true;
+                            }
+                            if (*l).at(i) != (*l2).at(i) {
+                                break false;
+                            }
+                            i += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn ne(lhs: @RLPItem, rhs: @RLPItem) -> bool {
+        // TODO optimize
+        !(lhs == rhs)
+    }
+}

crates/utils/src/tests.cairo

@@ -2,3 +2,4 @@ mod test_helpers;
 mod test_math;
 mod test_i256;
 mod test_traits;
+mod test_rlp;

crates/utils/src/tests/test_math.cairo

@@ -1,6 +1,6 @@
 use integer::{u256_overflowing_add, BoundedInt, u512};
 use utils::math::{
-    Exponentiation, WrappingExponentiation, u256_wide_add, Bitshift, WrappingBitshift
+    Exponentiation, WrappingExponentiation, u256_wide_add, Bitshift, WrappingBitshift, pow
 };
 
 #[test]