refactor(target_chains/starknet): remove Result from reader (#1536)

Riateche · web-flow · commit 308599714ff0 · 2024-05-02T15:48:55.000+01:00
diff --git a/target_chains/starknet/contracts/src/hash.cairo b/target_chains/starknet/contracts/src/hash.cairo
@@ -63,16 +63,9 @@ pub impl HasherImpl of HasherTrait {
                 // reader.len() < 8
                 chunk_len = reader.len().try_into().expect(UNEXPECTED_OVERFLOW);
             }
-            match reader.read_num_bytes(chunk_len) {
-                Result::Ok(value) => {
-                    // chunk_len <= 8 so value must fit in u64.
-                    self.push_to_last(value.try_into().expect(UNEXPECTED_OVERFLOW), chunk_len);
-                },
-                Result::Err(err) => {
-                    result = Result::Err(err);
-                    break;
-                },
-            }
+            let value = reader.read_num_bytes(chunk_len);
+            // chunk_len <= 8 so value must fit in u64.
+            self.push_to_last(value.try_into().expect(UNEXPECTED_OVERFLOW), chunk_len);
         };
         result
     }
diff --git a/target_chains/starknet/contracts/src/merkle_tree.cairo b/target_chains/starknet/contracts/src/merkle_tree.cairo
@@ -46,20 +46,13 @@ pub fn read_and_verify_proof(
     let mut message_reader = ReaderImpl::new(message.clone());
     let mut current_hash = leaf_hash(message_reader.clone()).map_err()?;
 
-    let proof_size = reader.read_u8().map_err()?;
+    let proof_size = reader.read_u8();
     let mut i = 0;
 
     let mut result = Result::Ok(());
     while i < proof_size {
-        match reader.read_u160().map_err() {
-            Result::Ok(sibling_digest) => {
-                current_hash = node_hash(current_hash, sibling_digest);
-            },
-            Result::Err(err) => {
-                result = Result::Err(err);
-                break;
-            },
-        }
+        let sibling_digest = reader.read_u160();
+        current_hash = node_hash(current_hash, sibling_digest);
         i += 1;
     };
     result?;
diff --git a/target_chains/starknet/contracts/src/pyth.cairo b/target_chains/starknet/contracts/src/pyth.cairo
@@ -357,30 +357,30 @@ mod pyth {
             ref self: ContractState, data: ByteArray
         ) -> Result<(), UpdatePriceFeedsError> {
             let mut reader = ReaderImpl::new(data);
-            let x = reader.read_u32().map_err()?;
+            let x = reader.read_u32();
             if x != ACCUMULATOR_MAGIC {
                 return Result::Err(UpdatePriceFeedsError::InvalidUpdateData);
             }
-            if reader.read_u8().map_err()? != MAJOR_VERSION {
+            if reader.read_u8() != MAJOR_VERSION {
                 return Result::Err(UpdatePriceFeedsError::InvalidUpdateData);
             }
-            if reader.read_u8().map_err()? < MINIMUM_ALLOWED_MINOR_VERSION {
+            if reader.read_u8() < MINIMUM_ALLOWED_MINOR_VERSION {
                 return Result::Err(UpdatePriceFeedsError::InvalidUpdateData);
             }
 
-            let trailing_header_size = reader.read_u8().map_err()?;
-            reader.skip(trailing_header_size).map_err()?;
+            let trailing_header_size = reader.read_u8();
+            reader.skip(trailing_header_size);
 
-            let update_type: Option<UpdateType> = reader.read_u8().map_err()?.try_into();
+            let update_type: Option<UpdateType> = reader.read_u8().try_into();
             match update_type {
                 Option::Some(v) => match v {
                     UpdateType::WormholeMerkle => {}
                 },
                 Option::None => { return Result::Err(UpdatePriceFeedsError::InvalidUpdateData); }
             };
 
-            let wh_proof_size = reader.read_u16().map_err()?;
-            let wh_proof = reader.read_byte_array(wh_proof_size.into()).map_err()?;
+            let wh_proof_size = reader.read_u16();
+            let wh_proof = reader.read_byte_array(wh_proof_size.into());
             let wormhole = IWormholeDispatcher { contract_address: self.wormhole_address.read() };
             let vm = wormhole.parse_and_verify_vm(wh_proof).map_err()?;
 
@@ -392,24 +392,24 @@ mod pyth {
             }
 
             let mut payload_reader = ReaderImpl::new(vm.payload);
-            let x = payload_reader.read_u32().map_err()?;
+            let x = payload_reader.read_u32();
             if x != ACCUMULATOR_WORMHOLE_MAGIC {
                 return Result::Err(UpdatePriceFeedsError::InvalidUpdateData);
             }
 
-            let update_type: Option<UpdateType> = payload_reader.read_u8().map_err()?.try_into();
+            let update_type: Option<UpdateType> = payload_reader.read_u8().try_into();
             match update_type {
                 Option::Some(v) => match v {
                     UpdateType::WormholeMerkle => {}
                 },
                 Option::None => { return Result::Err(UpdatePriceFeedsError::InvalidUpdateData); }
             };
 
-            let _slot = payload_reader.read_u64().map_err()?;
-            let _ring_size = payload_reader.read_u32().map_err()?;
-            let root_digest = payload_reader.read_u160().map_err()?;
+            let _slot = payload_reader.read_u64();
+            let _ring_size = payload_reader.read_u32();
+            let root_digest = payload_reader.read_u160();
 
-            let num_updates = reader.read_u8().map_err()?;
+            let num_updates = reader.read_u8();
 
             let total_fee = get_total_fee(ref self, num_updates);
             let fee_contract = IERC20CamelDispatcher {
@@ -451,27 +451,27 @@ mod pyth {
     fn read_and_verify_message(
         ref reader: Reader, root_digest: u256
     ) -> Result<PriceFeedMessage, UpdatePriceFeedsError> {
-        let message_size = reader.read_u16().map_err()?;
-        let message = reader.read_byte_array(message_size.into()).map_err()?;
+        let message_size = reader.read_u16();
+        let message = reader.read_byte_array(message_size.into());
         read_and_verify_proof(root_digest, @message, ref reader).map_err()?;
 
         let mut message_reader = ReaderImpl::new(message);
-        let message_type: Option<MessageType> = message_reader.read_u8().map_err()?.try_into();
+        let message_type: Option<MessageType> = message_reader.read_u8().try_into();
         match message_type {
             Option::Some(v) => match v {
                 MessageType::PriceFeed => {}
             },
             Option::None => { return Result::Err(UpdatePriceFeedsError::InvalidUpdateData); }
         };
 
-        let price_id = message_reader.read_u256().map_err()?;
-        let price = u64_as_i64(message_reader.read_u64().map_err()?);
-        let conf = message_reader.read_u64().map_err()?;
-        let expo = u32_as_i32(message_reader.read_u32().map_err()?);
-        let publish_time = message_reader.read_u64().map_err()?;
-        let prev_publish_time = message_reader.read_u64().map_err()?;
-        let ema_price = u64_as_i64(message_reader.read_u64().map_err()?);
-        let ema_conf = message_reader.read_u64().map_err()?;
+        let price_id = message_reader.read_u256();
+        let price = u64_as_i64(message_reader.read_u64());
+        let conf = message_reader.read_u64();
+        let expo = u32_as_i32(message_reader.read_u32());
+        let publish_time = message_reader.read_u64();
+        let prev_publish_time = message_reader.read_u64();
+        let ema_price = u64_as_i64(message_reader.read_u64());
+        let ema_conf = message_reader.read_u64();
 
         let message = PriceFeedMessage {
             price_id, price, conf, expo, publish_time, prev_publish_time, ema_price, ema_conf,
diff --git a/target_chains/starknet/contracts/src/reader.cairo b/target_chains/starknet/contracts/src/reader.cairo
@@ -42,112 +42,77 @@ 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, Error> {
+    fn read_num_bytes(ref self: Reader, num_bytes: u8) -> u128 {
         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);
-            return Result::Ok(x);
+            return self.read_from_current(num_bytes);
         }
         let num_low_bytes = num_bytes - self.num_current_bytes;
         let high = self.current;
-        self.fetch_next()?;
-        let low = self.read_num_bytes(num_low_bytes)?;
-        let value = if num_low_bytes == 16 {
+        self.fetch_next();
+        let low = self.read_num_bytes(num_low_bytes);
+        if num_low_bytes == 16 {
             low
         } else {
             high * one_shift_left_bytes_u128(num_low_bytes) + low
-        };
-        Result::Ok(value)
+        }
     }
 
-    fn read_u256(ref self: Reader) -> Result<u256, Error> {
-        let high = self.read_num_bytes(16)?;
-        let low = self.read_num_bytes(16)?;
+    fn read_u256(ref self: Reader) -> u256 {
+        let high = self.read_num_bytes(16);
+        let low = self.read_num_bytes(16);
         let value = u256 { high, low };
-        Result::Ok(value)
+        value
     }
-    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_u160(ref self: Reader) -> u256 {
+        let high = self.read_num_bytes(4);
+        let low = self.read_num_bytes(16);
+        u256 { high, low }
     }
-    fn read_u128(ref self: Reader) -> Result<u128, Error> {
+    fn read_u128(ref self: Reader) -> u128 {
         self.read_num_bytes(16)
     }
-    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_u64(ref self: Reader) -> u64 {
+        self.read_num_bytes(8).try_into().expect(UNEXPECTED_OVERFLOW)
     }
-    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_u32(ref self: Reader) -> u32 {
+        self.read_num_bytes(4).try_into().expect(UNEXPECTED_OVERFLOW)
     }
-    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_u16(ref self: Reader) -> u16 {
+        self.read_num_bytes(2).try_into().expect(UNEXPECTED_OVERFLOW)
     }
-    fn read_u8(ref self: Reader) -> Result<u8, Error> {
-        let value = self.read_num_bytes(1)?.try_into().expect(UNEXPECTED_OVERFLOW);
-        Result::Ok(value)
+    fn read_u8(ref self: Reader) -> u8 {
+        self.read_num_bytes(1).try_into().expect(UNEXPECTED_OVERFLOW)
     }
 
     // TODO: skip without calculating values
-    fn skip(ref self: Reader, mut num_bytes: u8) -> Result<(), Error> {
-        let mut result = Result::Ok(());
+    fn skip(ref self: Reader, mut num_bytes: u8) {
         while num_bytes > 0 {
             if num_bytes > 16 {
-                match self.read_num_bytes(16) {
-                    Result::Ok(_) => {},
-                    Result::Err(err) => {
-                        result = Result::Err(err);
-                        break;
-                    }
-                }
+                self.read_num_bytes(16);
                 num_bytes -= 16;
             } else {
-                match self.read_num_bytes(num_bytes) {
-                    Result::Ok(_) => {},
-                    Result::Err(err) => {
-                        result = Result::Err(err);
-                        break;
-                    }
-                }
-                break;
+                self.read_num_bytes(num_bytes);
             }
-        };
-        result
+        }
     }
 
     /// Reads the specified number of bytes as a new byte array.
-    fn read_byte_array(ref self: Reader, num_bytes: usize) -> Result<ByteArray, Error> {
+    fn read_byte_array(ref self: Reader, num_bytes: usize) -> ByteArray {
         let mut array: Array<bytes31> = array![];
-        let mut num_last_bytes = Option::None;
+        let mut num_last_bytes = 0;
         let mut num_remaining_bytes = num_bytes;
         loop {
-            let r = self.read_bytes_iteration(num_remaining_bytes, ref array);
-            match r {
-                Result::Ok((
-                    num_read, eof
-                )) => {
-                    num_remaining_bytes -= num_read;
-                    if eof {
-                        num_last_bytes = Option::Some(Result::Ok(num_read));
-                        break;
-                    }
-                },
-                Result::Err(err) => {
-                    num_last_bytes = Option::Some(Result::Err(err));
-                    break;
-                }
+            let (num_read, eof) = self.read_bytes_iteration(num_remaining_bytes, ref array);
+            num_remaining_bytes -= num_read;
+            if eof {
+                num_last_bytes = num_read;
+                break;
             }
         };
-        // `num_last_bytes` is always set to Some before break.
-        let num_last_bytes = num_last_bytes.unwrap()?;
         // num_last_bytes < 31
         let num_last_bytes = num_last_bytes.try_into().expect(UNEXPECTED_OVERFLOW);
-        let array = ByteArrayImpl::new(array, num_last_bytes);
-        Result::Ok(array)
+        ByteArrayImpl::new(array, num_last_bytes)
     }
 
     /// Returns number of remaining bytes to read.
@@ -179,15 +144,18 @@ 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<(), Error> {
+    fn fetch_next(ref self: Reader) {
         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(Error::UnexpectedEndOfInput)?;
+                let (value, bytes) = self
+                    .array
+                    .pop_front()
+                    .expect(Error::UnexpectedEndOfInput.into());
                 let value: u256 = value.into();
                 if bytes > 16 {
                     self.current = value.high;
@@ -199,33 +167,31 @@ impl ReaderPrivateImpl of ReaderPrivateTrait {
                 }
             },
         }
-        Result::Ok(())
     }
 
     // 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), Error> {
+    ) -> (usize, bool) {
         if num_bytes >= 31 {
-            let high = self.read_num_bytes(15)?;
-            let low = self.read_num_bytes(16)?;
+            let high = self.read_num_bytes(15);
+            let low = self.read_num_bytes(16);
             let value: felt252 = u256 { high, low }.try_into().expect(UNEXPECTED_OVERFLOW);
             array.append(value.try_into().expect(UNEXPECTED_OVERFLOW));
-            Result::Ok((31, false))
+            (31, false)
         } else if num_bytes > 16 {
             // num_bytes < 31
-            let high = self
-                .read_num_bytes((num_bytes - 16).try_into().expect(UNEXPECTED_OVERFLOW))?;
-            let low = self.read_num_bytes(16)?;
+            let high = self.read_num_bytes((num_bytes - 16).try_into().expect(UNEXPECTED_OVERFLOW));
+            let low = self.read_num_bytes(16);
             let value: felt252 = u256 { high, low }.try_into().expect(UNEXPECTED_OVERFLOW);
             array.append(value.try_into().expect(UNEXPECTED_OVERFLOW));
-            Result::Ok((num_bytes, true))
+            (num_bytes, true)
         } else {
             // bytes < 16
-            let low = self.read_num_bytes(num_bytes.try_into().expect(UNEXPECTED_OVERFLOW))?;
+            let low = self.read_num_bytes(num_bytes.try_into().expect(UNEXPECTED_OVERFLOW));
             let value: felt252 = low.try_into().expect(UNEXPECTED_OVERFLOW);
             array.append(value.try_into().expect(UNEXPECTED_OVERFLOW));
-            Result::Ok((num_bytes, true))
+            (num_bytes, true)
         }
     }
 }
diff --git a/target_chains/starknet/contracts/src/wormhole.cairo b/target_chains/starknet/contracts/src/wormhole.cairo
diff --git a/target_chains/starknet/contracts/tests/wormhole.cairo b/target_chains/starknet/contracts/tests/wormhole.cairo
