Revert "feat: integrate batch changes (#41)"

This reverts commit dbb9cb0.

Author: greged93

Cargo.lock

@@ -54,7 +54,6 @@ impl Batch {
                     let num_l1_messages = b.context.num_l1_messages as usize;
                     let block_messages = l1_messages_buf.get(..num_l1_messages).unwrap_or(&[]);
                     *l1_messages_buf = l1_messages_buf.get(num_l1_messages..).unwrap_or(&[]);
-
                     block_messages
                 })
                 .collect::<Vec<_>>();
@@ -114,7 +113,7 @@ fn hash_chunk(
 mod tests {
     use crate::decoding::{test_utils::read_to_bytes, v0::decode_v0, v1::decode_v1};
 
-    use alloy_primitives::b256;
+    use alloy_primitives::{address, b256, bytes, U256};
     use scroll_alloy_consensus::TxL1Message;
 
     #[test]
@@ -135,10 +134,35 @@ mod tests {
         // <https://etherscan.io/tx/0xdc0a315b25b46f4c1085e3884c63f8ede61e984e47655f7667e5f14e3df55f82>
         let raw_calldata = read_to_bytes("./testdata/calldata_v0_with_l1_messages.bin")?;
         let batch = decode_v0(&raw_calldata)?;
-        let l1_messages: Vec<TxL1Message> =
-            serde_json::from_str(&std::fs::read_to_string("./testdata/l1_messages_v0.json")?)?;
 
-        let hash = batch.try_compute_data_hash(&l1_messages).unwrap();
+        let hash = batch
+            .try_compute_data_hash(&[
+                TxL1Message {
+                    queue_index: 39,
+                    gas_limit: 180000,
+                    to: address!("781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC"),
+                    value: U256::ZERO,
+                    sender: address!("7885BcBd5CeCEf1336b5300fb5186A12DDD8c478"),
+                    input: bytes!("8ef1332e000000000000000000000000f1af3b23de0a5ca3cab7261cb0061c0d779a5c7b00000000000000000000000033b60d5dd260d453cac3782b0bdc01ce846721420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e48431f5c1000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb4800000000000000000000000006efdbff2a14a7c8e15944d1f4a48f9f95f663a4000000000000000000000000c451b0191351ce308fdfd779d73814c910fc5ecb000000000000000000000000c451b0191351ce308fdfd779d73814c910fc5ecb00000000000000000000000000000000000000000000000000000005d21dba0000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+                },
+                TxL1Message {
+                    queue_index: 40,
+                    gas_limit: 168000,
+                    to: address!("781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC"),
+                    value: U256::ZERO,
+                    sender: address!("7885BcBd5CeCEf1336b5300fb5186A12DDD8c478"),
+                    input: bytes!("8ef1332e0000000000000000000000007f2b8c31f88b6006c382775eea88297ec1e3e9050000000000000000000000006ea73e05adc79974b931123675ea8f78ffdacdf00000000000000000000000000000000000000000000000000011c37937e08000000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000a4232e8748000000000000000000000000b89db2813541287a4dd1fc6801eec30595ecdc6c000000000000000000000000b89db2813541287a4dd1fc6801eec30595ecdc6c0000000000000000000000000000000000000000000000000011c37937e080000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+                },
+                TxL1Message {
+                    queue_index: 41,
+                    gas_limit: 168000,
+                    to: address!("781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC"),
+                    value: U256::ZERO,
+                    sender: address!("7885BcBd5CeCEf1336b5300fb5186A12DDD8c478"),
+                    input: bytes!("8ef1332e0000000000000000000000007f2b8c31f88b6006c382775eea88297ec1e3e9050000000000000000000000006ea73e05adc79974b931123675ea8f78ffdacdf0000000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000002900000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000a4232e87480000000000000000000000003219c394111d45757ccb68a4fd353b4f7f9660960000000000000000000000003219c394111d45757ccb68a4fd353b4f7f966096000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+                },
+            ])
+            .unwrap();
 
         assert_eq!(hash, b256!("55fd647c58461d910b5bfb4539f2177ba575c9c8d578a344558976a4375cc287"));
 

crates/codec/src/decoding/batch.rs

@@ -1,5 +1,3 @@
-use alloy_primitives::U256;
-
 /// An error occurring during the codec process.
 #[derive(Debug, thiserror::Error)]
 pub enum CodecError {
@@ -15,8 +13,6 @@ pub enum DecodingError {
     MissingCodecVersion,
     #[error("unsupported codec version {0}")]
     UnsupportedCodecVersion(u8),
-    #[error("malformed codec version: {0}")]
-    MalformedCodecVersion(U256),
     #[error("missing blob from data source")]
     MissingBlob,
     #[error("missing chunk data")]

crates/codec/src/error.rs

@@ -13,7 +13,7 @@ use crate::decoding::{
 };
 
 use alloy_eips::eip4844::Blob;
-use alloy_primitives::{ruint::UintTryTo, Bytes, U256};
+use alloy_primitives::Bytes;
 
 /// The Codec.
 #[derive(Debug)]
@@ -43,7 +43,7 @@ impl Codec {
     /// Decodes the input data and returns the decoded [`Batch`].
     pub fn decode<T: CommitDataSource>(input: &T) -> Result<Batch, CodecError> {
         let calldata = input.calldata();
-        let version = get_codec_version(calldata)?;
+        let version = calldata.first().ok_or(DecodingError::MissingCodecVersion)?;
 
         let payload = match version {
             0 => decode_v0(calldata)?,
@@ -63,7 +63,7 @@ impl Codec {
                 let blob = input.blob().ok_or(DecodingError::MissingBlob)?;
                 decode_v7(blob.as_ref())?
             }
-            v => return Err(DecodingError::UnsupportedCodecVersion(v).into()),
+            v => return Err(DecodingError::UnsupportedCodecVersion(*v).into()),
         };
 
         Ok(payload)
@@ -77,23 +77,3 @@ pub trait CommitDataSource {
     /// Returns the blob for decoding.
     fn blob(&self) -> Option<&Blob>;
 }
-
-/// Returns the codec version from the calldata.
-fn get_codec_version(calldata: &[u8]) -> Result<u8, DecodingError> {
-    const CODEC_VERSION_OFFSET_START: usize = 4;
-    const CODEC_VERSION_LEN: usize = 32;
-    const CODEC_VERSION_OFFSET_END: usize = CODEC_VERSION_OFFSET_START + CODEC_VERSION_LEN;
-    const HIGH_BYTES_MASK: U256 =
-        U256::from_limbs([u64::MAX, u64::MAX, u64::MAX, 0xffffffffffffff00]);
-
-    let version = calldata
-        .get(CODEC_VERSION_OFFSET_START..CODEC_VERSION_OFFSET_END)
-        .ok_or(DecodingError::Eof)?;
-    let version = U256::from_be_slice(version);
-
-    if (version & HIGH_BYTES_MASK) != U256::ZERO {
-        return Err(DecodingError::MalformedCodecVersion(version))
-    }
-
-    Ok(version.uint_try_to().expect("fits in single byte"))
-}

crates/codec/src/lib.rs

@@ -46,14 +46,15 @@ impl From<DatabaseConnection> for Database {
 #[cfg(test)]
 mod test {
     use crate::{operations::DatabaseOperations, test_utils::setup_test_db};
-
     use arbitrary::{Arbitrary, Unstructured};
     use futures::StreamExt;
     use rand::Rng;
-    use rollup_node_primitives::{BatchCommitData, L1MessageWithBlockNumber};
+    use rollup_node_primitives::{
+        BatchInput, BatchInputV1, BatchInputV2, L1MessageWithBlockNumber,
+    };
 
     #[tokio::test]
-    async fn test_database_round_trip_batch_commit() {
+    async fn test_database_round_trip_batch_input() {
         // Set up the test database.
         let db = setup_test_db().await;
 
@@ -63,13 +64,24 @@ mod test {
         let mut u = Unstructured::new(&bytes);
 
         // Generate a random BatchInputV1.
-        let batch_commit = BatchCommitData::arbitrary(&mut u).unwrap();
+        let batch_input_v1 = BatchInputV1::arbitrary(&mut u).unwrap();
+        let batch_input = BatchInput::BatchInputDataV1(batch_input_v1);
+
+        // Round trip the BatchInput through the database.
+        db.insert_batch_input(batch_input.clone()).await.unwrap();
+        let batch_input_from_db =
+            db.get_batch_input_by_batch_index(batch_input.batch_index()).await.unwrap().unwrap();
+        assert_eq!(batch_input, batch_input_from_db);
+
+        // Generate a random BatchInputV2.
+        let batch_input_v2 = BatchInputV2::arbitrary(&mut u).unwrap();
+        let batch_input = BatchInput::BatchInputDataV2(batch_input_v2);
 
         // Round trip the BatchInput through the database.
-        db.insert_batch(batch_commit.clone()).await.unwrap();
-        let batch_commit_from_db =
-            db.get_batch_by_index(batch_commit.index).await.unwrap().unwrap();
-        assert_eq!(batch_commit, batch_commit_from_db);
+        db.insert_batch_input(batch_input.clone()).await.unwrap();
+        let batch_input_from_db =
+            db.get_batch_input_by_batch_index(batch_input.batch_index()).await.unwrap().unwrap();
+        assert_eq!(batch_input, batch_input_from_db);
     }
 
     #[tokio::test]

crates/codec/testdata/l1_messages_v0.json

@@ -0,0 +1,105 @@
+use std::ops::Deref;
+
+use rollup_node_primitives::{BatchInput as BatchInputPrimitive, BatchInputV1, BatchInputV2};
+use sea_orm::{entity::prelude::*, ActiveValue, FromJsonQueryResult};
+
+/// A database model that represents a batch input.
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "batch_input")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    index: i64,
+    version: u8,
+    codec_version: u8,
+    hash: Vec<u8>,
+    block_number: i64,
+    parent_batch_header: Vec<u8>,
+    #[sea_orm(column_type = "JsonBinary")]
+    chunks: Chunks,
+    skipped_l1_message_bitmap: Vec<u8>,
+    blob_hash: Vec<u8>,
+    finalized_block_number: Option<i64>,
+}
+
+/// The relation for the batch input model.
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+/// The active model behavior for the batch input model.
+impl ActiveModelBehavior for ActiveModel {}
+
+/// A wrapper for a list of chunks.
+#[derive(
+    Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, FromJsonQueryResult,
+)]
+pub struct Chunks(pub Vec<Vec<u8>>);
+
+impl Deref for Chunks {
+    type Target = Vec<Vec<u8>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<BatchInputPrimitive> for ActiveModel {
+    fn from(batch_input: BatchInputPrimitive) -> Self {
+        let (version, batch_input_v1, blob_hash) = match batch_input {
+            BatchInputPrimitive::BatchInputDataV1(batch_input) => (1, batch_input, vec![]),
+            BatchInputPrimitive::BatchInputDataV2(batch_input) => {
+                (2, batch_input.batch_input_base, batch_input.blob_hash.to_vec())
+            }
+        };
+        Self {
+            index: ActiveValue::Set(
+                batch_input_v1.batch_index.try_into().expect("index should fit in i64"),
+            ),
+            version: ActiveValue::Set(version),
+            codec_version: ActiveValue::Set(batch_input_v1.version),
+            hash: ActiveValue::Set(batch_input_v1.batch_hash.to_vec()),
+            block_number: ActiveValue::Set(
+                batch_input_v1.block_number.try_into().expect("block number should fit in i64"),
+            ),
+            parent_batch_header: ActiveValue::Set(batch_input_v1.parent_batch_header),
+            chunks: ActiveValue::Set(Chunks(batch_input_v1.chunks)),
+            skipped_l1_message_bitmap: ActiveValue::Set(batch_input_v1.skipped_l1_message_bitmap),
+            blob_hash: ActiveValue::Set(blob_hash),
+            finalized_block_number: ActiveValue::Unchanged(None),
+        }
+    }
+}
+
+impl From<Model> for BatchInputPrimitive {
+    fn from(value: Model) -> Self {
+        let chunks = value.chunks.0;
+        let batch_input_v1 = BatchInputV1 {
+            version: value.codec_version,
+            batch_index: value.index.try_into().expect("data persisted in database is valid"),
+            batch_hash: value
+                .hash
+                .as_slice()
+                .try_into()
+                .expect("data persisted in database is valid"),
+            block_number: value
+                .block_number
+                .try_into()
+                .expect("data persisted in database is valid"),
+            parent_batch_header: value.parent_batch_header,
+            chunks,
+            skipped_l1_message_bitmap: value.skipped_l1_message_bitmap,
+        };
+
+        if value.version == 1 {
+            Self::BatchInputDataV1(batch_input_v1)
+        } else {
+            Self::BatchInputDataV2(BatchInputV2 {
+                batch_input_base: batch_input_v1,
+                blob_hash: value
+                    .blob_hash
+                    .as_slice()
+                    .try_into()
+                    .expect("data persisted in database is valid"),
+            })
+        }
+    }
+}

crates/database/db/src/db.rs

@@ -1,5 +1,5 @@
-/// This module contains the batch commit database model.
-pub mod batch_commit;
+/// This module contains the batch input database model.
+pub mod batch_input;
 
 /// This module contains the L1 message database model.
 pub mod l1_message;