diff --git a/crates/astria-core/src/generated/astria.sequencerblock.v1.rs b/crates/astria-core/src/generated/astria.sequencerblock.v1.rs index 6f00c4ffc..9a6ac3bc8 100644 --- a/crates/astria-core/src/generated/astria.sequencerblock.v1.rs +++ b/crates/astria-core/src/generated/astria.sequencerblock.v1.rs @@ -244,6 +244,47 @@ impl ::prost::Name for RollupData { ::prost::alloc::format!("astria.sequencerblock.v1.{}", Self::NAME) } } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataItem { + #[prost(oneof = "data_item::Value", tags = "1, 2, 3, 4")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `DataItem`. +pub mod data_item { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct UpgradeChangeHashes { + #[prost(bytes = "bytes", repeated, tag = "1")] + pub hashes: ::prost::alloc::vec::Vec<::prost::bytes::Bytes>, + } + impl ::prost::Name for UpgradeChangeHashes { + const NAME: &'static str = "UpgradeChangeHashes"; + const PACKAGE: &'static str = "astria.sequencerblock.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("astria.sequencerblock.v1.DataItem.{}", Self::NAME) + } + } + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(bytes, tag = "1")] + RollupTransactionsRoot(::prost::bytes::Bytes), + #[prost(bytes, tag = "2")] + RollupIdsRoot(::prost::bytes::Bytes), + #[prost(message, tag = "3")] + UpgradeChangeHashes(UpgradeChangeHashes), + #[prost(bytes, tag = "4")] + ExtendedCommitInfo(::prost::bytes::Bytes), + } +} +impl ::prost::Name for DataItem { + const NAME: &'static str = "DataItem"; + const PACKAGE: &'static str = "astria.sequencerblock.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("astria.sequencerblock.v1.{}", Self::NAME) + } +} /// If no upgrade change hashes exist in the block, this will be the third item in the cometbft /// block data field, otherwise it will be fourth. #[allow(clippy::derive_partial_eq_without_eq)] diff --git a/crates/astria-core/src/generated/astria.sequencerblock.v1.serde.rs b/crates/astria-core/src/generated/astria.sequencerblock.v1.serde.rs index 9aeed6805..a8fb6a623 100644 --- a/crates/astria-core/src/generated/astria.sequencerblock.v1.serde.rs +++ b/crates/astria-core/src/generated/astria.sequencerblock.v1.serde.rs @@ -1,3 +1,236 @@ +impl serde::Serialize for DataItem { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.v1.DataItem", len)?; + if let Some(v) = self.value.as_ref() { + match v { + data_item::Value::RollupTransactionsRoot(v) => { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("rollupTransactionsRoot", pbjson::private::base64::encode(&v).as_str())?; + } + data_item::Value::RollupIdsRoot(v) => { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("rollupIdsRoot", pbjson::private::base64::encode(&v).as_str())?; + } + data_item::Value::UpgradeChangeHashes(v) => { + struct_ser.serialize_field("upgradeChangeHashes", v)?; + } + data_item::Value::ExtendedCommitInfo(v) => { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("extendedCommitInfo", pbjson::private::base64::encode(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DataItem { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "rollup_transactions_root", + "rollupTransactionsRoot", + "rollup_ids_root", + "rollupIdsRoot", + "upgrade_change_hashes", + "upgradeChangeHashes", + "extended_commit_info", + "extendedCommitInfo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + RollupTransactionsRoot, + RollupIdsRoot, + UpgradeChangeHashes, + ExtendedCommitInfo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "rollupTransactionsRoot" | "rollup_transactions_root" => Ok(GeneratedField::RollupTransactionsRoot), + "rollupIdsRoot" | "rollup_ids_root" => Ok(GeneratedField::RollupIdsRoot), + "upgradeChangeHashes" | "upgrade_change_hashes" => Ok(GeneratedField::UpgradeChangeHashes), + "extendedCommitInfo" | "extended_commit_info" => Ok(GeneratedField::ExtendedCommitInfo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DataItem; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct astria.sequencerblock.v1.DataItem") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::RollupTransactionsRoot => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("rollupTransactionsRoot")); + } + value__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| data_item::Value::RollupTransactionsRoot(x.0)); + } + GeneratedField::RollupIdsRoot => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("rollupIdsRoot")); + } + value__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| data_item::Value::RollupIdsRoot(x.0)); + } + GeneratedField::UpgradeChangeHashes => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeChangeHashes")); + } + value__ = map_.next_value::<::std::option::Option<_>>()?.map(data_item::Value::UpgradeChangeHashes) +; + } + GeneratedField::ExtendedCommitInfo => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("extendedCommitInfo")); + } + value__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| data_item::Value::ExtendedCommitInfo(x.0)); + } + } + } + Ok(DataItem { + value: value__, + }) + } + } + deserializer.deserialize_struct("astria.sequencerblock.v1.DataItem", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for data_item::UpgradeChangeHashes { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.hashes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.v1.DataItem.UpgradeChangeHashes", len)?; + if !self.hashes.is_empty() { + struct_ser.serialize_field("hashes", &self.hashes.iter().map(pbjson::private::base64::encode).collect::>())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for data_item::UpgradeChangeHashes { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hashes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Hashes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "hashes" => Ok(GeneratedField::Hashes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = data_item::UpgradeChangeHashes; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct astria.sequencerblock.v1.DataItem.UpgradeChangeHashes") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hashes__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Hashes => { + if hashes__.is_some() { + return Err(serde::de::Error::duplicate_field("hashes")); + } + hashes__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(data_item::UpgradeChangeHashes { + hashes: hashes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("astria.sequencerblock.v1.DataItem.UpgradeChangeHashes", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for Deposit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result diff --git a/crates/astria-core/src/protocol/test_utils.rs b/crates/astria-core/src/protocol/test_utils.rs index 81729f9b5..b685a223a 100644 --- a/crates/astria-core/src/protocol/test_utils.rs +++ b/crates/astria-core/src/protocol/test_utils.rs @@ -220,10 +220,8 @@ impl ConfigureSequencerBlock { let mut data = if use_data_items { vec![ - DataItem::RollupTransactionsRoot(rollup_transactions_tree.root()) - .encode() - .unwrap(), - DataItem::RollupIdsRoot(rollup_ids_root).encode().unwrap(), + DataItem::RollupTransactionsRoot(rollup_transactions_tree.root()).encode(), + DataItem::RollupIdsRoot(rollup_ids_root).encode(), ] } else { vec![ @@ -279,9 +277,7 @@ pub fn upgrade_change_hashes() -> Vec { #[must_use] pub fn upgrade_change_hashes_bytes() -> Bytes { - DataItem::UpgradeChangeHashes(upgrade_change_hashes()) - .encode() - .unwrap() + DataItem::UpgradeChangeHashes(upgrade_change_hashes()).encode() } #[must_use] @@ -305,7 +301,6 @@ pub fn minimal_extended_commit_info_bytes() -> Bytes { .into(), ) .encode() - .unwrap() } #[must_use] diff --git a/crates/astria-core/src/sequencerblock/v1/block/mod.rs b/crates/astria-core/src/sequencerblock/v1/block/mod.rs index 7370a6629..511d86970 100644 --- a/crates/astria-core/src/sequencerblock/v1/block/mod.rs +++ b/crates/astria-core/src/sequencerblock/v1/block/mod.rs @@ -4,14 +4,9 @@ mod tests; use std::{ collections::HashMap, fmt::Display, - io, sync::Arc, }; -use borsh::{ - BorshDeserialize, - BorshSerialize, -}; use bytes::Bytes; use indexmap::IndexMap; use prost::Message as _; @@ -1252,7 +1247,6 @@ enum ExtendedCommitInfoErrorKind { /// a different hash from their original one by CometBFT, making it difficult for clients to /// identify their txs and meaning they would not be cleared out of the CometBFT mempool when added /// to a block. -#[derive(BorshSerialize, BorshDeserialize)] pub enum DataItem { RollupTransactionsRoot([u8; SHA256_DIGEST_LENGTH]), RollupIdsRoot([u8; SHA256_DIGEST_LENGTH]), @@ -1262,9 +1256,9 @@ pub enum DataItem { impl DataItem { /// The number of bytes output by [`Self::encode`] when `self` is `RollupIdsRoot`. - pub const ENCODED_ROLLUP_IDS_ROOT_LENGTH: usize = SHA256_DIGEST_LENGTH + 1; + pub const ENCODED_ROLLUP_IDS_ROOT_LENGTH: usize = SHA256_DIGEST_LENGTH + 2; /// The number of bytes output by [`Self::encode`] when `self` is `RollupTransactionsRoot`. - pub const ENCODED_ROLLUP_TRANSACTIONS_ROOT_LENGTH: usize = SHA256_DIGEST_LENGTH + 1; + pub const ENCODED_ROLLUP_TRANSACTIONS_ROOT_LENGTH: usize = SHA256_DIGEST_LENGTH + 2; const EXTENDED_COMMIT_INFO_VARIANT_NAME: &'static str = "extended commit info"; const ROLLUP_IDS_ROOT_VARIANT_NAME: &'static str = "rollup ids root"; const ROLLUP_TXS_ROOT_VARIANT_NAME: &'static str = "rollup transactions root"; @@ -1279,25 +1273,76 @@ impl DataItem { } } - /// Returns the Borsh-encoded bytes of `self`. - /// - /// # Errors - /// - /// Returns an error if encoding fails. - pub fn encode(&self) -> Result { - borsh::to_vec(self) - .map(Bytes::from) - .map_err(|source| DataItemError::encode(source, self.variant_name())) + /// Returns the protobuf-encoded bytes of `self`. + pub fn encode(&self) -> Bytes { + let value = match self { + DataItem::RollupTransactionsRoot(root) => { + raw::data_item::Value::RollupTransactionsRoot(Bytes::copy_from_slice(root)) + } + DataItem::RollupIdsRoot(root) => { + raw::data_item::Value::RollupIdsRoot(Bytes::copy_from_slice(root)) + } + DataItem::UpgradeChangeHashes(change_hashes) => { + let hashes = change_hashes + .iter() + .map(|change_hash| Bytes::copy_from_slice(change_hash.as_bytes())) + .collect(); + raw::data_item::Value::UpgradeChangeHashes(raw::data_item::UpgradeChangeHashes { + hashes, + }) + } + DataItem::ExtendedCommitInfo(info) => { + raw::data_item::Value::ExtendedCommitInfo(info.clone()) + } + }; + raw::DataItem { + value: Some(value), + } + .encode_to_vec() + .into() } - /// Decodes a `DataItem` from the Borsh-encoded `bytes`. + /// Decodes a `DataItem` from the protobuf-encoded `bytes`. /// /// # Errors /// /// Returns an error if decoding fails. fn decode(index_in_data_collection: usize, bytes: &[u8]) -> Result { - borsh::from_slice::(bytes) - .map_err(|source| DataItemError::decode(source, index_in_data_collection)) + let raw = raw::DataItem::decode(bytes) + .map_err(|source| DataItemError::decode(source, index_in_data_collection))?; + let value = raw + .value + .ok_or_else(|| DataItemError::field_not_set("value"))?; + match value { + raw::data_item::Value::RollupTransactionsRoot(root) => { + let decoded_root = root.as_ref().try_into().map_err(|_| { + DataItemError::incorrect_hash_length("rollup_transactions_root", root.len()) + })?; + Ok(DataItem::RollupTransactionsRoot(decoded_root)) + } + raw::data_item::Value::RollupIdsRoot(root) => { + let decoded_root = root.as_ref().try_into().map_err(|_| { + DataItemError::incorrect_hash_length("rollup_ids_root", root.len()) + })?; + Ok(DataItem::RollupIdsRoot(decoded_root)) + } + raw::data_item::Value::UpgradeChangeHashes(hashes) => { + let decoded_hashes = hashes + .hashes + .into_iter() + .map(|hash| { + let bytes = hash.as_ref().try_into().map_err(|_| { + DataItemError::incorrect_hash_length("upgrade_change_hash", hash.len()) + })?; + Ok(ChangeHash::new(bytes)) + }) + .collect::>()?; + Ok(DataItem::UpgradeChangeHashes(decoded_hashes)) + } + raw::data_item::Value::ExtendedCommitInfo(info) => { + Ok(DataItem::ExtendedCommitInfo(info)) + } + } } fn into_rollup_transactions_root( @@ -1356,17 +1401,21 @@ impl DataItem { pub struct DataItemError(DataItemErrorKind); impl DataItemError { - fn encode(source: io::Error, variant: &'static str) -> Self { - Self(DataItemErrorKind::Encode { + fn decode(source: prost::DecodeError, index: usize) -> Self { + Self(DataItemErrorKind::Decode { source, - variant, + index, }) } - fn decode(source: io::Error, index: usize) -> Self { - Self(DataItemErrorKind::Decode { - source, - index, + fn field_not_set(field: &'static str) -> Self { + Self(DataItemErrorKind::FieldNotSet(field)) + } + + fn incorrect_hash_length(name: &'static str, actual: usize) -> Self { + Self(DataItemErrorKind::IncorrectHashLength { + name, + actual, }) } @@ -1381,13 +1430,15 @@ impl DataItemError { #[derive(Debug, thiserror::Error)] enum DataItemErrorKind { - #[error("failed to borsh-encode {variant} as data item")] - Encode { - source: io::Error, - variant: &'static str, + #[error("item {index} of cometbft `block.data` could not be protobuf-decoded")] + Decode { + source: prost::DecodeError, + index: usize, }, - #[error("item {index} of cometbft `block.data` could not be borsh-decoded")] - Decode { source: io::Error, index: usize }, + #[error("the expected field in the raw source type was not set: `{0}`")] + FieldNotSet(&'static str), + #[error("{name} hash must have exactly 32 bytes, but {actual} bytes provided")] + IncorrectHashLength { name: &'static str, actual: usize }, #[error("unexpected data element `{actual}` at index {index}, expected `{expected}`")] Mismatch { index: usize, @@ -1486,7 +1537,7 @@ impl ExpandedBlockData { } /// Constructs a new `ExpandedBlockData` from `data`, expecting the entries to be in the - /// post-upgrade1 form of Borsh-encoded `DataItem`s. + /// post-upgrade1 form of protobuf-encoded `DataItem`s. /// /// The expected order is: /// - `RollupTransactionsRoot` diff --git a/crates/astria-core/src/sequencerblock/v1/block/tests.rs b/crates/astria-core/src/sequencerblock/v1/block/tests.rs index d46aad0f4..c8f84f079 100644 --- a/crates/astria-core/src/sequencerblock/v1/block/tests.rs +++ b/crates/astria-core/src/sequencerblock/v1/block/tests.rs @@ -75,10 +75,7 @@ fn block_to_filtered_roundtrip() { #[test] fn encoded_rollup_txs_root_length_should_be_correct() { assert_eq!( - DataItem::RollupTransactionsRoot([1; 32]) - .encode() - .unwrap() - .len(), + DataItem::RollupTransactionsRoot([1; 32]).encode().len(), DataItem::ENCODED_ROLLUP_TRANSACTIONS_ROOT_LENGTH ); } @@ -86,7 +83,7 @@ fn encoded_rollup_txs_root_length_should_be_correct() { #[test] fn encoded_rollup_ids_root_length_should_be_correct() { assert_eq!( - DataItem::RollupIdsRoot([1; 32]).encode().unwrap().len(), + DataItem::RollupIdsRoot([1; 32]).encode().len(), DataItem::ENCODED_ROLLUP_IDS_ROOT_LENGTH ); } @@ -96,9 +93,7 @@ fn rollup_txs_root_legacy_bytes() -> Bytes { } fn rollup_txs_root_bytes() -> Bytes { - DataItem::RollupTransactionsRoot(ROLLUP_TXS_ROOT) - .encode() - .unwrap() + DataItem::RollupTransactionsRoot(ROLLUP_TXS_ROOT).encode() } fn rollup_ids_root_legacy_bytes() -> Bytes { @@ -106,7 +101,7 @@ fn rollup_ids_root_legacy_bytes() -> Bytes { } fn rollup_ids_root_bytes() -> Bytes { - DataItem::RollupIdsRoot(ROLLUP_IDS_ROOT).encode().unwrap() + DataItem::RollupIdsRoot(ROLLUP_IDS_ROOT).encode() } fn tx(nonce: u32) -> Transaction { diff --git a/crates/astria-core/src/upgrades/v1/change_hash.rs b/crates/astria-core/src/upgrades/v1/change_hash.rs index 53285d033..10de219f5 100644 --- a/crates/astria-core/src/upgrades/v1/change_hash.rs +++ b/crates/astria-core/src/upgrades/v1/change_hash.rs @@ -9,14 +9,10 @@ use base64::{ display::Base64Display, engine::general_purpose::STANDARD, }; -use borsh::{ - BorshDeserialize, - BorshSerialize, -}; use thiserror::Error; /// A SHA256 digest of a Borsh-encoded upgrade change. -#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, BorshSerialize, BorshDeserialize)] +#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)] pub struct ChangeHash([u8; 32]); impl ChangeHash { diff --git a/crates/astria-sequencer/src/app/mod.rs b/crates/astria-sequencer/src/app/mod.rs index 9d6c35f01..704efa6ac 100644 --- a/crates/astria-sequencer/src/app/mod.rs +++ b/crates/astria-sequencer/src/app/mod.rs @@ -422,11 +422,7 @@ impl App { let encoded_upgrade_change_hashes = if upgrade_change_hashes.is_empty() { None } else { - Some( - DataItem::UpgradeChangeHashes(upgrade_change_hashes) - .encode() - .wrap_err("failed to encode upgrade change hashes")?, - ) + Some(DataItem::UpgradeChangeHashes(upgrade_change_hashes).encode()) }; let uses_data_item_enum = self.uses_data_item_enum(prepare_proposal.height); @@ -472,8 +468,7 @@ impl App { let mut encoded_extended_commit_info = DataItem::ExtendedCommitInfo( extended_commit_info.into_raw().encode_to_vec().into(), ) - .encode() - .wrap_err("failed to encode extended commit info")?; + .encode(); if block_size_constraints .cometbft_checked_add(encoded_extended_commit_info.len()) @@ -485,9 +480,7 @@ impl App { encoded_extended_commit_info_len = encoded_extended_commit_info.len(), "extended commit info is too large to fit in block; not including in block" ); - encoded_extended_commit_info = DataItem::ExtendedCommitInfo(Bytes::new()) - .encode() - .wrap_err("failed to encode empty extended commit info")?; + encoded_extended_commit_info = DataItem::ExtendedCommitInfo(Bytes::new()).encode(); block_size_constraints .cometbft_checked_add(encoded_extended_commit_info.len()) .wrap_err("exceeded size limit while adding empty extended commit info")?; @@ -516,8 +509,7 @@ impl App { generate_rollup_datas_commitment::(&signed_txs_included, deposits).into_iter() } else { generate_rollup_datas_commitment::(&signed_txs_included, deposits).into_iter() - } - .wrap_err("failed to generate commitments")?; + }; let txs = commitments_iter .chain(encoded_upgrade_change_hashes.into_iter()) diff --git a/crates/astria-sequencer/src/app/test_utils.rs b/crates/astria-sequencer/src/app/test_utils.rs index 681826e2b..aa662af52 100644 --- a/crates/astria-sequencer/src/app/test_utils.rs +++ b/crates/astria-sequencer/src/app/test_utils.rs @@ -189,12 +189,10 @@ pub(crate) fn transactions_with_extended_commit_info_and_commitments( let extended_commit_info = ExtendedCommitInfoWithCurrencyPairMapping::empty(0u16.into()); let encoded_extended_commit_info = DataItem::ExtendedCommitInfo(extended_commit_info.into_raw().encode_to_vec().into()) - .encode() - .unwrap(); + .encode(); let commitments = generate_rollup_datas_commitment::(txs, deposits.unwrap_or_default()); let txs_with_commit_info: Vec = commitments .into_iter() - .unwrap() .chain(std::iter::once(encoded_extended_commit_info)) .chain(txs.iter().map(|tx| tx.to_raw().encode_to_vec().into())) .collect(); diff --git a/crates/astria-sequencer/src/proposal/commitment.rs b/crates/astria-sequencer/src/proposal/commitment.rs index a9de8ce47..68a1a89fe 100644 --- a/crates/astria-sequencer/src/proposal/commitment.rs +++ b/crates/astria-sequencer/src/proposal/commitment.rs @@ -15,10 +15,6 @@ use astria_core::{ RollupData, }, }; -use astria_eyre::eyre::{ - Result, - WrapErr, -}; use bytes::Bytes; /// Wrapper for values returned by [`generate_rollup_datas_commitment`]. @@ -41,22 +37,24 @@ impl GeneratedCommitments 64 } } +} + +impl IntoIterator for GeneratedCommitments { + type IntoIter = std::array::IntoIter; + type Item = Bytes; - pub(crate) fn into_iter(self) -> Result> { + fn into_iter(self) -> Self::IntoIter { if USES_DATA_ITEM_ENUM { - let rollup_datas_root = DataItem::RollupTransactionsRoot(self.rollup_datas_root) - .encode() - .wrap_err("failed to encode rollup transactions root")?; - let rollup_ids_root = DataItem::RollupIdsRoot(self.rollup_ids_root) - .encode() - .wrap_err("failed to encode rollup ids root")?; - Ok([rollup_datas_root, rollup_ids_root].into_iter()) + let rollup_datas_root = + DataItem::RollupTransactionsRoot(self.rollup_datas_root).encode(); + let rollup_ids_root = DataItem::RollupIdsRoot(self.rollup_ids_root).encode(); + [rollup_datas_root, rollup_ids_root].into_iter() } else { - Ok([ + [ self.rollup_datas_root.to_vec().into(), self.rollup_ids_root.to_vec().into(), ] - .into_iter()) + .into_iter() } } } diff --git a/crates/astria-sequencer/src/service/consensus.rs b/crates/astria-sequencer/src/service/consensus.rs index 64e732c13..9aef4cb91 100644 --- a/crates/astria-sequencer/src/service/consensus.rs +++ b/crates/astria-sequencer/src/service/consensus.rs @@ -465,7 +465,7 @@ mod tests { .err() .unwrap() ); - let expected = "item 0 of cometbft `block.data` could not be borsh-decoded"; + let expected = "item 0 of cometbft `block.data` could not be protobuf-decoded"; assert!( error_message.contains(expected), "`{error_message}` didn't contain `{expected}`" @@ -476,9 +476,7 @@ mod tests { async fn process_proposal_fail_wrong_commitment_value() { let (mut consensus_service, _) = new_consensus_service(None).await; let mut process_proposal = new_process_proposal_request(&[]); - process_proposal.txs[0] = DataItem::RollupTransactionsRoot([99u8; 32]) - .encode() - .unwrap(); + process_proposal.txs[0] = DataItem::RollupTransactionsRoot([99u8; 32]).encode(); let error_message = format!( "{:#}", consensus_service diff --git a/proto/sequencerblockapis/astria/sequencerblock/v1/block.proto b/proto/sequencerblockapis/astria/sequencerblock/v1/block.proto index bddaa9543..f4e4b8905 100644 --- a/proto/sequencerblockapis/astria/sequencerblock/v1/block.proto +++ b/proto/sequencerblockapis/astria/sequencerblock/v1/block.proto @@ -153,6 +153,18 @@ message RollupData { } } +message DataItem { + message UpgradeChangeHashes { + repeated bytes hashes = 1; + } + oneof value { + bytes rollup_transactions_root = 1; + bytes rollup_ids_root = 2; + UpgradeChangeHashes upgrade_change_hashes = 3; + bytes extended_commit_info = 4; + } +} + // If no upgrade change hashes exist in the block, this will be the third item in the cometbft // block data field, otherwise it will be fourth. message ExtendedCommitInfoWithProof {