feat: align PROPOSAL_MAX_BLOCKS to 192 (#660)

* feat: align PROPOSAL_MAX_BLOCKS to 192

* fix: fix CI

* chore: update gaiko

* feat(shasta): enhance validation of L2 block header `extra_data` in batch processing

- Added early validation for Shasta-specific `extra_data` in the `batch_preflight` function to improve error reporting.
- Implemented a new utility function to decode and validate `extra_data` for Shasta blocks, ensuring consistency with proposal data.
- Updated the `calculate_batch_blocks_final_header` function to assert `extra_data` validity post-execution for simplicity.

* chore: fix compile warning

* Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* refactor(shasta): simplify extra_data decoding and validation

- Removed the endOfProposalFlag from the decode_shasta_extra_data function, reducing the expected length of extra_data from 8 to 7 bytes.
- Updated validation logic in validate_shasta_extra_data_for_batch to reflect the changes in extra_data structure, improving clarity and maintainability.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: smtmfft

core/src/preflight/mod.rs

@@ -294,6 +294,20 @@ pub async fn batch_preflight<BDP: BlockDataProvider>(
         taiko: taiko_guest_batch_input.clone(),
     };
 
+    // Shasta-only: verify the L2 block header `extra_data` matches the proposal decoding and the request.
+    //
+    // Note: the same rule is enforced inside the guests (via `calculate_batch_blocks_final_header`),
+    // but we also fail early here for better error reporting and less wasted work.
+    if let BlockProposedFork::Shasta(_) = &mock_guest_batch_input.taiko.batch_proposed {
+        if !raiko_lib::utils::shasta_rules::validate_shasta_extra_data_for_batch(
+            &mock_guest_batch_input,
+        ) {
+            return Err(RaikoError::Preflight(
+                "invalid shasta extra_data in batch input".to_string(),
+            ));
+        }
+    }
+
     // distribute txs to each block
     let pool_txs_list: Vec<(Vec<TransactionSigned>, bool)> =
         generate_transactions_for_batch_blocks(&mock_guest_batch_input);

gaiko

@@ -31,7 +31,7 @@
                 "RISC0": null
             }
         },
-        "genesis_time": 1768276900,
+        "genesis_time": 1769395300,
         "seconds_per_slot": 12,
         "is_taiko": false
     },
@@ -50,7 +50,7 @@
                 "Block": 0
             },
             "SHASTA": {
-                "Timestamp": 0
+                "Timestamp": 1769396301
             },
             "CANCUN": "TBD"
         },
@@ -69,16 +69,16 @@
         "beacon_rpc": null,
         "verifier_address_forks": {
             "PACAYA": {
-                "SGX": "0xf0ebc67dB56A5687649fF2216e3826a52F8DBd7c",
+                "SGX": "0x9D351F6E72e3095F24dD854c9B8CA69F99A2C538",
                 "SP1": "0xCb2D625BF8C2187B180646aF4738AF5F1413Fb70",
                 "RISC0": "0x48940F7ab2C674Aa66C09eDa71614aD704E9d007",
-                "SGXGETH": "0xfE3EdF3e778a647c0955f2a5f79565E272E6AfdB"
+                "SGXGETH": "0x6B455442C8C4cAC2e09c40409E8bf7FfcdB1Fc50"
             },
             "SHASTA": {
-                "SGX": "0xf0ebc67dB56A5687649fF2216e3826a52F8DBd7c",
+                "SGX": "0x9D351F6E72e3095F24dD854c9B8CA69F99A2C538",
                 "SP1": "0xCb2D625BF8C2187B180646aF4738AF5F1413Fb70",
                 "RISC0": "0x48940F7ab2C674Aa66C09eDa71614aD704E9d007",
-                "SGXGETH": "0xfE3EdF3e778a647c0955f2a5f79565E272E6AfdB"
+                "SGXGETH": "0x6B455442C8C4cAC2e09c40409E8bf7FfcdB1Fc50"
             }
         },
         "genesis_time": 0,

host/config/chain_spec_list_devnet.json

@@ -85,6 +85,12 @@ pub fn calculate_batch_blocks_final_header(input: &GuestBatchInput) -> Vec<Block
 // 1. connect parent hash & state root
 // 2. block number should be in sequence
 fn validate_final_batch_blocks(input: &GuestBatchInput, final_blocks: &[Block]) {
+    // Shasta-only: validate extra_data once, post-execution, to keep code simple.
+    assert!(
+        crate::utils::shasta_rules::validate_shasta_extra_data_for_batch(input),
+        "invalid shasta extra_data in batch input"
+    );
+
     input
         .inputs
         .iter()

lib/src/builder.rs

@@ -2,7 +2,7 @@ use alloy_rlp::{Decodable, Encodable};
 use anyhow::Result;
 
 use super::types::{DerivationSourceManifest, ProtocolBlockManifest};
-use crate::utils::blobs::{zlib_compress_data, zlib_decompress_data};
+use crate::utils::blobs::zlib_compress_data;
 
 /// Encode and compress a Shasta proposal manifest (equivalent to Go's EncodeAndCompressShastaProposal)
 pub fn encode_and_compress_shasta_proposal(proposal: &DerivationSourceManifest) -> Result<Vec<u8>> {
@@ -15,20 +15,6 @@ pub fn encode_and_compress_shasta_proposal(proposal: &DerivationSourceManifest)
     Ok(compressed)
 }
 
-/// Decode and decompress a Shasta proposal manifest
-pub fn decode_and_decompress_shasta_proposal(
-    compressed_data: &[u8],
-) -> Result<DerivationSourceManifest> {
-    // First, decompress the data
-    let rlp_encoded = zlib_decompress_data(compressed_data)?;
-
-    // Then RLP decode
-    let mut data = rlp_encoded.as_slice();
-    let proposal = DerivationSourceManifest::decode(&mut data)?;
-
-    Ok(proposal)
-}
-
 impl Encodable for ProtocolBlockManifest {
     fn encode(&self, out: &mut dyn alloy_rlp::BufMut) {
         // Calculate the payload length first
@@ -107,7 +93,7 @@ impl Encodable for DerivationSourceManifest {
     }
 }
 
-pub(crate) const PROPOSAL_MAX_BLOCKS: usize = 384;
+pub(crate) const PROPOSAL_MAX_BLOCKS: usize = 192;
 
 impl Decodable for DerivationSourceManifest {
     fn decode(buf: &mut &[u8]) -> Result<Self, alloy_rlp::Error> {
@@ -134,6 +120,7 @@ impl Decodable for DerivationSourceManifest {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::utils::blobs::zlib_decompress_data;
     use alloy_primitives::Address;
 
     fn create_test_proposal() -> DerivationSourceManifest {
@@ -202,4 +189,18 @@ mod tests {
         // Decode and decompress
         let _decoded = decode_and_decompress_shasta_proposal(&encoded).unwrap();
     }
+
+    /// Decode and decompress a Shasta proposal manifest
+    fn decode_and_decompress_shasta_proposal(
+        compressed_data: &[u8],
+    ) -> Result<DerivationSourceManifest> {
+        // First, decompress the data
+        let rlp_encoded = zlib_decompress_data(compressed_data)?;
+
+        // Then RLP decode
+        let mut data = rlp_encoded.as_slice();
+        let proposal = DerivationSourceManifest::decode(&mut data)?;
+
+        Ok(proposal)
+    }
 }

lib/src/manifest/codec.rs

@@ -6,7 +6,7 @@ use std::cmp::max as std_max;
 use tracing::warn;
 
 use crate::consts::ForkCondition;
-use crate::input::{GuestBatchInput, GuestInput};
+use crate::input::{BlockProposedFork, GuestBatchInput, GuestInput};
 use crate::manifest::{DerivationSourceManifest, ProtocolBlockManifest, PROPOSAL_MAX_BLOCKS};
 #[cfg(not(feature = "std"))]
 use crate::no_std::*;
@@ -15,6 +15,104 @@ pub const BOND_PROCESSING_DELAY: usize = 6;
 
 pub const ANCHOR_MAX_OFFSET: usize = 128;
 
+/// Decode Shasta `extra_data` layout (per `Derivation.md`):
+/// - byte[0]    => basefeeSharingPctg (uint8)
+/// - byte[1..6] => proposalId (uint48, big-endian)
+fn decode_shasta_extra_data(extra_data: &[u8]) -> Option<(u8, u64)> {
+    if extra_data.len() < 7 {
+        warn!(
+            "invalid shasta extra_data length: {} (need at least 7 bytes)",
+            extra_data.len()
+        );
+        return None;
+    }
+
+    let basefee_sharing_pctg = extra_data[0];
+    let proposal_id = u64::from_be_bytes([
+        0,
+        0,
+        extra_data[1],
+        extra_data[2],
+        extra_data[3],
+        extra_data[4],
+        extra_data[5],
+        extra_data[6],
+    ]);
+
+    Some((basefee_sharing_pctg, proposal_id))
+}
+
+/// Validate Shasta `extra_data` for all blocks in this proposal batch.
+///
+/// Enforced in guests (ZKVM programs) by calling from `calculate_batch_blocks_final_header`,
+/// so the proof itself rejects malformed `extra_data` even if host-side preflight is bypassed.
+pub fn validate_shasta_extra_data_for_batch(input: &GuestBatchInput) -> bool {
+    let BlockProposedFork::Shasta(event_data) = &input.taiko.batch_proposed else {
+        return true;
+    };
+
+    if input.inputs.is_empty() {
+        warn!("empty shasta batch input");
+        return false;
+    }
+
+    let expected_basefee_sharing_pctg = event_data.proposal.basefeeSharingPctg;
+    let expected_proposal_id = input.taiko.batch_id;
+
+    for guest_input in input.inputs.iter() {
+        let header = &guest_input.block.header;
+        let Some((basefee_sharing_pctg, proposal_id)) =
+            decode_shasta_extra_data(header.extra_data.as_ref())
+        else {
+            warn!(
+                "failed to decode shasta extra_data for block {}",
+                header.number
+            );
+            return false;
+        };
+
+        if basefee_sharing_pctg != expected_basefee_sharing_pctg {
+            warn!(
+                "shasta extra_data basefeeSharingPctg mismatch for block {}: got {}, expected {}",
+                header.number, basefee_sharing_pctg, expected_basefee_sharing_pctg
+            );
+            return false;
+        }
+        if proposal_id != expected_proposal_id {
+            warn!(
+                "shasta extra_data proposalId mismatch for block {}: got {}, expected {}",
+                header.number, proposal_id, expected_proposal_id
+            );
+            return false;
+        }
+    }
+
+    // Optional: the parent of the 1st block should belong to the previous proposal.
+    if expected_proposal_id > 0 {
+        let parent_header = &input.inputs[0].parent_header;
+        let Some((_parent_pctg, parent_proposal_id)) =
+            decode_shasta_extra_data(parent_header.extra_data.as_ref())
+        else {
+            warn!(
+                "failed to decode shasta extra_data for parent of first block {} (parent {})",
+                input.inputs[0].block.header.number, parent_header.number
+            );
+            return false;
+        };
+        if parent_proposal_id != expected_proposal_id - 1 {
+            warn!(
+                "shasta parent extra_data proposalId mismatch for parent {}: got {}, expected {}",
+                parent_header.number,
+                parent_proposal_id,
+                expected_proposal_id - 1
+            );
+            return false;
+        }
+    }
+
+    true
+}
+
 pub(crate) fn valid_anchor_in_normal_proposal(
     blocks: &[ProtocolBlockManifest],
     last_anchor_block_number: u64,

lib/src/utils/shasta_rules.rs

@@ -478,7 +478,7 @@ mod tests {
             prove: false,
         };
         let spec_id = taiko_chain_spec
-            .active_fork(1, 0)
+            .active_fork(0, 1869396301)
             .map_err(|e| ProverError::GuestError(e.to_string()))
             .expect("ok");
         assert_eq!(spec_id, SpecId::SHASTA);
@@ -494,7 +494,7 @@ mod tests {
         assert_eq!(instance_id, 10);
 
         let spec_id = taiko_chain_spec
-            .active_fork(15, 0)
+            .active_fork(15, 1869396301)
             .map_err(|e| ProverError::GuestError(e.to_string()))
             .expect("ok");
         assert_eq!(spec_id, SpecId::SHASTA);