refactor(target_chains/starknet): rename ByteArray to ByteBuffer (#1665)

Author: Riateche

target_chains/starknet/contracts/src/byte_array.cairo renamed to target_chains/starknet/contracts/src/byte_buffer.cairo

@@ -5,17 +5,17 @@ use super::util::one_shift_left_bytes_u256;
 /// A byte array with storage format similar to `core::ByteArray`, but
 /// suitable for reading data from it.
 #[derive(Drop, Clone, Serde)]
-pub struct ByteArray {
+pub struct ByteBuffer {
     // Number of bytes stored in the last item of `self.data` (or 0 if it's empty).
     num_last_bytes: u8,
     // Bytes in big endian. Each item except the last one stores 31 bytes.
     // If `num_last_bytes < 31`, unused most significant bytes of the last item will be unused.
     data: Array<felt252>,
 }
 
-impl DebugByteArray of Debug<ByteArray> {
-    fn fmt(self: @ByteArray, ref f: Formatter) -> Result<(), core::fmt::Error> {
-        write!(f, "ByteArray {{ num_last_bytes: {}, data: [", self.num_last_bytes)?;
+impl DebugByteBuffer of Debug<ByteBuffer> {
+    fn fmt(self: @ByteBuffer, ref f: Formatter) -> Result<(), core::fmt::Error> {
+        write!(f, "ByteBuffer {{ num_last_bytes: {}, data: [", self.num_last_bytes)?;
         let mut data = self.data.clone();
         loop {
             match data.pop_front() {
@@ -28,9 +28,9 @@ impl DebugByteArray of Debug<ByteArray> {
 }
 
 #[generate_trait]
-pub impl ByteArrayImpl of ByteArrayTrait {
+pub impl ByteBufferImpl of ByteBufferTrait {
     /// Creates a byte array with the data.
-    fn new(data: Array<felt252>, num_last_bytes: u8) -> ByteArray {
+    fn new(data: Array<felt252>, num_last_bytes: u8) -> ByteBuffer {
         if data.len() == 0 {
             assert!(num_last_bytes == 0);
         } else {
@@ -39,15 +39,15 @@ pub impl ByteArrayImpl of ByteArrayTrait {
             let last: u256 = (*data.at(data.len() - 1)).into();
             assert!(
                 last / one_shift_left_bytes_u256(num_last_bytes) == 0,
-                "ByteArrayImpl::new: last value is too large"
+                "ByteBufferImpl::new: last value is too large"
             );
         }
-        ByteArray { num_last_bytes, data }
+        ByteBuffer { num_last_bytes, data }
     }
 
     /// Removes 31 or less bytes from the start of the array.
     /// Returns the value and the number of bytes.
-    fn pop_front(ref self: ByteArray) -> Option<(felt252, u8)> {
+    fn pop_front(ref self: ByteBuffer) -> Option<(felt252, u8)> {
         let item = self.data.pop_front()?;
         if self.data.is_empty() {
             let num_bytes = self.num_last_bytes;
@@ -58,7 +58,7 @@ pub impl ByteArrayImpl of ByteArrayTrait {
         }
     }
 
-    fn len(self: @ByteArray) -> usize {
+    fn len(self: @ByteBuffer) -> usize {
         if self.data.is_empty() {
             0
         } else {
@@ -69,19 +69,19 @@ pub impl ByteArrayImpl of ByteArrayTrait {
 
 #[cfg(test)]
 mod tests {
-    use super::{ByteArray, ByteArrayImpl};
+    use super::{ByteBuffer, ByteBufferImpl};
     use pyth::util::array_try_into;
 
     #[test]
     fn empty_byte_array() {
-        let mut array = ByteArrayImpl::new(array![], 0);
+        let mut array = ByteBufferImpl::new(array![], 0);
         assert!(array.len() == 0);
         assert!(array.pop_front() == Option::None);
     }
 
     #[test]
     fn byte_array_3_zeros() {
-        let mut array = ByteArrayImpl::new(array![0], 3);
+        let mut array = ByteBufferImpl::new(array![0], 3);
         assert!(array.len() == 3);
         assert!(array.pop_front() == Option::Some((0, 3)));
         assert!(array.len() == 0);
@@ -90,7 +90,7 @@ mod tests {
 
     #[test]
     fn byte_array_3_bytes() {
-        let mut array = ByteArrayImpl::new(array![0x010203], 3);
+        let mut array = ByteBufferImpl::new(array![0x010203], 3);
         assert!(array.len() == 3);
         assert!(array.pop_front() == Option::Some((0x010203, 3)));
         assert!(array.len() == 0);
@@ -100,7 +100,7 @@ mod tests {
     #[test]
     fn byte_array_single_full() {
         let value_31_bytes = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f;
-        let mut array = ByteArrayImpl::new(array![value_31_bytes], 31);
+        let mut array = ByteBufferImpl::new(array![value_31_bytes], 31);
         assert!(array.len() == 31);
         assert!(array.pop_front() == Option::Some((value_31_bytes, 31)));
         assert!(array.len() == 0);
@@ -111,7 +111,7 @@ mod tests {
     fn byte_array_two_full() {
         let value_31_bytes = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f;
         let value2_31_bytes = 0x2122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f;
-        let mut array = ByteArrayImpl::new(array![value_31_bytes, value2_31_bytes], 31);
+        let mut array = ByteBufferImpl::new(array![value_31_bytes, value2_31_bytes], 31);
         assert!(array.len() == 62);
         assert!(array.pop_front() == Option::Some((value_31_bytes, 31)));
         assert!(array.len() == 31);
@@ -125,7 +125,7 @@ mod tests {
         let value_31_bytes = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f;
         let value2_31_bytes = 0x2122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f;
         let value3_5_bytes = 0x4142434445;
-        let mut array = ByteArrayImpl::new(
+        let mut array = ByteBufferImpl::new(
             array![value_31_bytes, value2_31_bytes, value3_5_bytes], 5
         );
         assert!(array.len() == 67);
@@ -140,24 +140,24 @@ mod tests {
     #[test]
     #[should_panic]
     fn byte_array_empty_invalid() {
-        ByteArrayImpl::new(array![], 5);
+        ByteBufferImpl::new(array![], 5);
     }
 
     #[test]
     #[should_panic]
     fn byte_array_last_too_large() {
-        ByteArrayImpl::new(array![1, 2, 3], 35);
+        ByteBufferImpl::new(array![1, 2, 3], 35);
     }
 
     #[test]
     #[should_panic]
     fn byte_array_last_zero_invalid() {
-        ByteArrayImpl::new(array![1, 2, 0], 0);
+        ByteBufferImpl::new(array![1, 2, 0], 0);
     }
 
     #[test]
     #[should_panic]
     fn byte_array_last_too_many_bytes() {
-        ByteArrayImpl::new(array![1, 2, 0x010203], 2);
+        ByteBufferImpl::new(array![1, 2, 0x010203], 2);
     }
 }

target_chains/starknet/contracts/src/lib.cairo

@@ -1,12 +1,12 @@
 pub mod pyth;
 pub mod wormhole;
-pub mod byte_array;
+pub mod byte_buffer;
 pub mod reader;
 pub mod hash;
 pub mod util;
 pub mod merkle_tree;
 
-pub use byte_array::{ByteArray, ByteArrayTrait};
+pub use byte_buffer::{ByteBuffer, ByteBufferTrait};
 pub use pyth::{
     Event, PriceFeedUpdated, WormholeAddressSet, GovernanceDataSourceSet, ContractUpgraded,
     DataSourcesSet, FeeSet, GetPriceUnsafeError, GovernanceActionError, UpdatePriceFeedsError,

target_chains/starknet/contracts/src/merkle_tree.cairo

@@ -1,6 +1,6 @@
 use super::hash::{Hasher, HasherImpl};
 use super::reader::{Reader, ReaderImpl};
-use super::byte_array::ByteArray;
+use super::byte_buffer::ByteBuffer;
 use super::util::ONE_SHIFT_96;
 use core::cmp::{min, max};
 use core::panic_with_felt252;
@@ -49,7 +49,7 @@ fn node_hash(a: u256, b: u256) -> u256 {
     hasher.finalize() / ONE_SHIFT_96
 }
 
-pub fn read_and_verify_proof(root_digest: u256, message: @ByteArray, ref reader: Reader) {
+pub fn read_and_verify_proof(root_digest: u256, message: @ByteBuffer, ref reader: Reader) {
     let mut message_reader = ReaderImpl::new(message.clone());
     let mut current_hash = leaf_hash(message_reader.clone());
 

target_chains/starknet/contracts/src/pyth.cairo

@@ -26,7 +26,7 @@ mod pyth {
         parse_wormhole_proof
     };
     use pyth::reader::{Reader, ReaderImpl};
-    use pyth::byte_array::{ByteArray, ByteArrayImpl};
+    use pyth::byte_buffer::{ByteBuffer, ByteBufferImpl};
     use core::panic_with_felt252;
     use core::starknet::{
         ContractAddress, get_caller_address, get_execution_info, ClassHash, SyscallResultTrait,
@@ -260,11 +260,11 @@ mod pyth {
             info.publish_time
         }
 
-        fn update_price_feeds(ref self: ContractState, data: ByteArray) {
+        fn update_price_feeds(ref self: ContractState, data: ByteBuffer) {
             self.update_price_feeds_internal(data, array![], 0, 0, false);
         }
 
-        fn get_update_fee(self: @ContractState, data: ByteArray, token: ContractAddress) -> u256 {
+        fn get_update_fee(self: @ContractState, data: ByteBuffer, token: ContractAddress) -> u256 {
             let single_update_fee = if token == self.fee_token_address1.read() {
                 self.single_update_fee1.read()
             } else if token == self.fee_token_address2.read() {
@@ -283,7 +283,7 @@ mod pyth {
 
         fn update_price_feeds_if_necessary(
             ref self: ContractState,
-            update: ByteArray,
+            update: ByteBuffer,
             required_publish_times: Array<PriceFeedPublishTime>
         ) {
             let mut i = 0;
@@ -305,7 +305,7 @@ mod pyth {
 
         fn parse_price_feed_updates(
             ref self: ContractState,
-            data: ByteArray,
+            data: ByteBuffer,
             price_ids: Array<u256>,
             min_publish_time: u64,
             max_publish_time: u64
@@ -318,7 +318,7 @@ mod pyth {
 
         fn parse_unique_price_feed_updates(
             ref self: ContractState,
-            data: ByteArray,
+            data: ByteBuffer,
             price_ids: Array<u256>,
             publish_time: u64,
             max_staleness: u64,
@@ -383,7 +383,7 @@ mod pyth {
             wormhole.chain_id()
         }
 
-        fn execute_governance_instruction(ref self: ContractState, data: ByteArray) {
+        fn execute_governance_instruction(ref self: ContractState, data: ByteBuffer) {
             let wormhole = IWormholeDispatcher { contract_address: self.wormhole_address.read() };
             let vm = wormhole.parse_and_verify_vm(data.clone());
             self.verify_governance_vm(@vm);
@@ -510,7 +510,7 @@ mod pyth {
         }
 
         fn check_new_wormhole(
-            ref self: ContractState, wormhole_address: ContractAddress, vm: ByteArray
+            ref self: ContractState, wormhole_address: ContractAddress, vm: ByteBuffer
         ) {
             let wormhole = IWormholeDispatcher { contract_address: wormhole_address };
             let vm = wormhole.parse_and_verify_vm(vm);
@@ -545,7 +545,7 @@ mod pyth {
             }
         }
 
-        fn authorize_governance_transfer(ref self: ContractState, claim_vaa: ByteArray) {
+        fn authorize_governance_transfer(ref self: ContractState, claim_vaa: ByteBuffer) {
             let wormhole = IWormholeDispatcher { contract_address: self.wormhole_address.read() };
             let claim_vm = wormhole.parse_and_verify_vm(claim_vaa.clone());
             // Note: no verify_governance_vm() because claim_vaa is signed by the new data source
@@ -604,7 +604,7 @@ mod pyth {
         // for any of the specified feeds.
         fn update_price_feeds_internal(
             ref self: ContractState,
-            data: ByteArray,
+            data: ByteBuffer,
             price_ids: Array<u256>,
             min_publish_time: u64,
             max_publish_time: u64,

target_chains/starknet/contracts/src/pyth/fake_upgrades.cairo

@@ -11,7 +11,7 @@ pub trait IFakePyth<T> {
 #[starknet::contract]
 mod pyth_fake_upgrade1 {
     use pyth::pyth::{GetPriceUnsafeError, DataSource, Price};
-    use pyth::byte_array::ByteArray;
+    use pyth::byte_buffer::ByteBuffer;
 
     #[storage]
     struct Storage {}
@@ -36,7 +36,7 @@ mod pyth_fake_upgrade1 {
 #[starknet::contract]
 mod pyth_fake_upgrade_wrong_magic {
     use pyth::pyth::{GetPriceUnsafeError, DataSource, Price};
-    use pyth::byte_array::ByteArray;
+    use pyth::byte_buffer::ByteBuffer;
 
     #[storage]
     struct Storage {}

target_chains/starknet/contracts/src/pyth/governance.cairo

@@ -1,7 +1,7 @@
 use pyth::reader::ReaderTrait;
 use core::array::ArrayTrait;
 use pyth::reader::{Reader, ReaderImpl};
-use pyth::byte_array::ByteArray;
+use pyth::byte_buffer::ByteBuffer;
 use pyth::pyth::errors::GovernanceActionError;
 use core::panic_with_felt252;
 use core::starknet::{ContractAddress, ClassHash};
@@ -82,7 +82,7 @@ pub struct AuthorizeGovernanceDataSourceTransfer {
     // Transfer governance control over this contract to another data source.
     // The claim_vaa field is a VAA created by the new data source; using a VAA prevents mistakes
     // in the handoff by ensuring that the new data source can send VAAs (i.e., is not an invalid address).
-    pub claim_vaa: ByteArray,
+    pub claim_vaa: ByteBuffer,
 }
 
 #[derive(Drop, Debug)]
@@ -94,7 +94,7 @@ pub struct UpgradeContract {
     pub new_implementation: ClassHash,
 }
 
-pub fn parse_instruction(payload: ByteArray) -> GovernanceInstruction {
+pub fn parse_instruction(payload: ByteBuffer) -> GovernanceInstruction {
     let mut reader = ReaderImpl::new(payload);
     let magic = reader.read_u32();
     if magic != MAGIC {

target_chains/starknet/contracts/src/pyth/interface.cairo

@@ -1,5 +1,5 @@
 use super::{GetPriceUnsafeError, GetPriceNoOlderThanError};
-use pyth::byte_array::ByteArray;
+use pyth::byte_buffer::ByteBuffer;
 use pyth::wormhole::VerifiedVM;
 use core::starknet::ContractAddress;
 
@@ -20,21 +20,25 @@ pub trait IPyth<T> {
     fn price_feed_exists(self: @T, price_id: u256) -> bool;
     fn latest_price_info_publish_time(self: @T, price_id: u256) -> u64;
 
-    fn update_price_feeds(ref self: T, data: ByteArray);
+    fn update_price_feeds(ref self: T, data: ByteBuffer);
     fn update_price_feeds_if_necessary(
-        ref self: T, update: ByteArray, required_publish_times: Array<PriceFeedPublishTime>
+        ref self: T, update: ByteBuffer, required_publish_times: Array<PriceFeedPublishTime>
     );
     fn parse_price_feed_updates(
         ref self: T,
-        data: ByteArray,
+        data: ByteBuffer,
         price_ids: Array<u256>,
         min_publish_time: u64,
         max_publish_time: u64
     ) -> Array<PriceFeed>;
     fn parse_unique_price_feed_updates(
-        ref self: T, data: ByteArray, price_ids: Array<u256>, publish_time: u64, max_staleness: u64,
+        ref self: T,
+        data: ByteBuffer,
+        price_ids: Array<u256>,
+        publish_time: u64,
+        max_staleness: u64,
     ) -> Array<PriceFeed>;
-    fn get_update_fee(self: @T, data: ByteArray, token: ContractAddress) -> u256;
+    fn get_update_fee(self: @T, data: ByteBuffer, token: ContractAddress) -> u256;
     fn wormhole_address(self: @T) -> ContractAddress;
     fn fee_token_addresses(self: @T) -> Array<ContractAddress>;
     fn get_single_update_fee(self: @T, token: ContractAddress) -> u256;
@@ -46,7 +50,7 @@ pub trait IPyth<T> {
     fn governance_data_source_index(self: @T) -> u32;
     fn chain_id(self: @T) -> u16;
 
-    fn execute_governance_instruction(ref self: T, data: ByteArray);
+    fn execute_governance_instruction(ref self: T, data: ByteBuffer);
     fn version(self: @T) -> felt252;
     fn pyth_upgradable_magic(self: @T) -> u32;
 }

target_chains/starknet/contracts/src/pyth/price_update.cairo

@@ -1,7 +1,7 @@
 use pyth::reader::{Reader, ReaderImpl};
 use pyth::pyth::{UpdatePriceFeedsError, PriceFeed, Price};
 use core::panic_with_felt252;
-use pyth::byte_array::ByteArray;
+use pyth::byte_buffer::ByteBuffer;
 use pyth::merkle_tree::read_and_verify_proof;
 use pyth::util::{u32_as_i32, u64_as_i64};
 
@@ -88,7 +88,7 @@ pub fn read_and_verify_header(ref reader: Reader) {
     }
 }
 
-pub fn parse_wormhole_proof(payload: ByteArray) -> u256 {
+pub fn parse_wormhole_proof(payload: ByteBuffer) -> u256 {
     let mut reader = ReaderImpl::new(payload);
     if reader.read_u32() != ACCUMULATOR_WORMHOLE_MAGIC {
         panic_with_felt252(UpdatePriceFeedsError::InvalidUpdateData.into());