refactor(target_chains/starknet): use enum errors

Author: Riateche

target_chains/starknet/contracts/src/hash.cairo

@@ -55,7 +55,7 @@ pub impl HasherImpl of HasherTrait {
 
     /// Reads all remaining data from the reader and pushes it to
     /// the hashing buffer.
-    fn push_reader(ref self: Hasher, ref reader: Reader) -> Result<(), felt252> {
+    fn push_reader(ref self: Hasher, ref reader: Reader) -> Result<(), pyth::reader::Error> {
         let mut result = Result::Ok(());
         while reader.len() > 0 {
             let mut chunk_len = 8 - self.num_last_bytes;

target_chains/starknet/contracts/src/lib.cairo

@@ -2,4 +2,4 @@ pub mod pyth;
 pub mod wormhole;
 pub mod reader;
 pub mod hash;
-mod util;
+pub mod util;

target_chains/starknet/contracts/src/reader.cairo

@@ -5,8 +5,17 @@ use core::integer::u128_byte_reverse;
 use core::fmt::{Debug, Formatter};
 use pyth::util::{UNEXPECTED_OVERFLOW, UNEXPECTED_ZERO, one_shift_left_bytes_u128};
 
-pub mod errors {
-    pub const EOF: felt252 = 'unexpected end of input';
+#[derive(Copy, Drop, Debug, Serde, PartialEq)]
+pub enum Error {
+    UnexpectedEndOfInput,
+}
+
+impl ErrorIntoFelt252 of Into<Error, felt252> {
+    fn into(self: Error) -> felt252 {
+        match self {
+            Error::UnexpectedEndOfInput => 'unexpected end of input',
+        }
+    }
 }
 
 /// A byte array with storage format similar to `core::ByteArray`, but
@@ -95,7 +104,7 @@ pub impl ReaderImpl of ReaderTrait {
     }
 
     /// Reads the specified number of bytes (up to 16) as a big endian unsigned integer.
-    fn read_num_bytes(ref self: Reader, num_bytes: u8) -> Result<u128, felt252> {
+    fn read_num_bytes(ref self: Reader, num_bytes: u8) -> Result<u128, Error> {
         assert!(num_bytes <= 16, "Reader::read_num_bytes: num_bytes is too large");
         if num_bytes <= self.num_current_bytes {
             let x = self.read_from_current(num_bytes);
@@ -113,40 +122,40 @@ pub impl ReaderImpl of ReaderTrait {
         Result::Ok(value)
     }
 
-    fn read_u256(ref self: Reader) -> Result<u256, felt252> {
+    fn read_u256(ref self: Reader) -> Result<u256, Error> {
         let high = self.read_num_bytes(16)?;
         let low = self.read_num_bytes(16)?;
         let value = u256 { high, low };
         Result::Ok(value)
     }
-    fn read_u160(ref self: Reader) -> Result<u256, felt252> {
+    fn read_u160(ref self: Reader) -> Result<u256, Error> {
         let high = self.read_num_bytes(4)?;
         let low = self.read_num_bytes(16)?;
         let value = u256 { high, low };
         Result::Ok(value)
     }
-    fn read_u128(ref self: Reader) -> Result<u128, felt252> {
+    fn read_u128(ref self: Reader) -> Result<u128, Error> {
         self.read_num_bytes(16)
     }
-    fn read_u64(ref self: Reader) -> Result<u64, felt252> {
+    fn read_u64(ref self: Reader) -> Result<u64, Error> {
         let value = self.read_num_bytes(8)?.try_into().expect(UNEXPECTED_OVERFLOW);
         Result::Ok(value)
     }
-    fn read_u32(ref self: Reader) -> Result<u32, felt252> {
+    fn read_u32(ref self: Reader) -> Result<u32, Error> {
         let value = self.read_num_bytes(4)?.try_into().expect(UNEXPECTED_OVERFLOW);
         Result::Ok(value)
     }
-    fn read_u16(ref self: Reader) -> Result<u16, felt252> {
+    fn read_u16(ref self: Reader) -> Result<u16, Error> {
         let value = self.read_num_bytes(2)?.try_into().expect(UNEXPECTED_OVERFLOW);
         Result::Ok(value)
     }
-    fn read_u8(ref self: Reader) -> Result<u8, felt252> {
+    fn read_u8(ref self: Reader) -> Result<u8, Error> {
         let value = self.read_num_bytes(1)?.try_into().expect(UNEXPECTED_OVERFLOW);
         Result::Ok(value)
     }
 
     // TODO: skip without calculating values
-    fn skip(ref self: Reader, mut num_bytes: u8) -> Result<(), felt252> {
+    fn skip(ref self: Reader, mut num_bytes: u8) -> Result<(), Error> {
         let mut result = Result::Ok(());
         while num_bytes > 0 {
             if num_bytes > 16 {
@@ -173,7 +182,7 @@ pub impl ReaderImpl of ReaderTrait {
     }
 
     /// Reads the specified number of bytes as a new byte array.
-    fn read_byte_array(ref self: Reader, num_bytes: usize) -> Result<ByteArray, felt252> {
+    fn read_byte_array(ref self: Reader, num_bytes: usize) -> Result<ByteArray, Error> {
         let mut array: Array<bytes31> = array![];
         let mut num_last_bytes = Option::None;
         let mut num_remaining_bytes = num_bytes;
@@ -232,15 +241,15 @@ impl ReaderPrivateImpl of ReaderPrivateTrait {
     /// Replenishes `self.current` and `self.num_current_bytes`.
     /// This should only be called when all bytes from `self.current` has been read.
     /// Returns `EOF` error if no more data is available.
-    fn fetch_next(ref self: Reader) -> Result<(), felt252> {
+    fn fetch_next(ref self: Reader) -> Result<(), Error> {
         match self.next {
             Option::Some(next) => {
                 self.next = Option::None;
                 self.current = next;
                 self.num_current_bytes = 16;
             },
             Option::None => {
-                let (value, bytes) = self.array.pop_front().ok_or(errors::EOF)?;
+                let (value, bytes) = self.array.pop_front().ok_or(Error::UnexpectedEndOfInput)?;
                 let value: u256 = value.into();
                 if bytes > 16 {
                     self.current = value.high;
@@ -258,7 +267,7 @@ impl ReaderPrivateImpl of ReaderPrivateTrait {
     // Moved out from `read_bytes` because we cannot use `return` or `?` within a loop.
     fn read_bytes_iteration(
         ref self: Reader, num_bytes: usize, ref array: Array<bytes31>
-    ) -> Result<(usize, bool), felt252> {
+    ) -> Result<(usize, bool), Error> {
         if num_bytes >= 31 {
             let high = self.read_num_bytes(15)?;
             let low = self.read_num_bytes(16)?;

target_chains/starknet/contracts/src/util.cairo

@@ -54,3 +54,11 @@ pub fn u64_byte_reverse(value: u64) -> u64 {
     let reversed = u128_byte_reverse(value.into()) / ONE_SHIFT_64.try_into().expect('not zero');
     reversed.try_into().unwrap()
 }
+
+/// If `self` is an error, panics with a `felt252` value
+/// corresponding to the error. Otherwise, returns the success value.
+/// This differs from `Result::unwrap` which always panics with
+/// the same message and doesn't include information about the error.
+pub trait UnwrapWithFelt252<T, E> {
+    fn unwrap_with_felt252(self: Result<T, E>) -> T;
+}