chore(fast-inbox): drop inHash from parity and checkpoint header circuits (A-1387)

Remove the dead unconstrained in_hash pass-through from InboxParity and
ParityPublicInputs, and remove in_hash from the CheckpointHeader consensus
format (struct, to_be_bytes, serialization length, Empty, hash fixtures). The
Inbox rolling hash is now the checkpoint's only inbox commitment.

Retire NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP in favor of
MAX_L1_TO_L2_MSGS_PER_CHECKPOINT, and drop the now-unused
L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH and the NUM_MSGS_PER_BASE_PARITY /
NUM_BASE_PARITY_PER_ROOT_PARITY frontier fan-in constants. Regenerated
constants.gen.ts and ConstantsGen.sol via remake-constants.

Author: spalladino

l1-contracts/src/core/libraries/ConstantsGen.sol

@@ -26,6 +26,4 @@ library Constants {
   uint256 internal constant FEE_JUICE_ADDRESS = 3;
   uint256 internal constant BLS12_POINT_COMPRESSED_BYTES = 48;
   uint256 internal constant ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH = 113;
-  uint256 internal constant NUM_MSGS_PER_BASE_PARITY = 256;
-  uint256 internal constant NUM_BASE_PARITY_PER_ROOT_PARITY = 4;
 }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/parity_public_inputs.nr

@@ -3,12 +3,6 @@ use types::traits::{Deserialize, Empty, Serialize};
 
 #[derive(Deserialize, Eq, Serialize)]
 pub struct ParityPublicInputs {
-    // The L1 `in_hash`: the sha256 frontier root of the checkpoint's L1-to-L2 messages, checked on L1 against
-    // `inbox.consume()`. It is an UNCONSTRAINED pass-through: `InboxParity` echoes the value the prover supplies and
-    // does not recompute it from the messages (the frontier tree is gone from the parity body). Until the Fast Inbox
-    // flip moves the L1 anchor to the rolling hash, `in_hash` remains the authoritative L1 check, so the prover must
-    // supply the true frontier root; the in-circuit tie between it and the processed messages is deferred to the flip.
-    pub in_hash: Field,
     // Rolling hash of the Inbox message chain before absorbing this checkpoint's messages.
     pub start_rolling_hash: Field,
     // Rolling hash of the Inbox message chain after absorbing the `num_msgs` real messages. Each link is
@@ -29,7 +23,6 @@ pub struct ParityPublicInputs {
 impl Empty for ParityPublicInputs {
     fn empty() -> Self {
         ParityPublicInputs {
-            in_hash: 0,
             start_rolling_hash: 0,
             end_rolling_hash: 0,
             start_sponge: L1ToL2MessageSponge::empty(),

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_rollup_public_inputs_composer.nr

@@ -21,8 +21,8 @@ use types::{
 
 pub struct CheckpointRollupPublicInputsComposer<let NumBlobs: u32> {
     merged_rollup: BlockRollupPublicInputs,
-    // Public inputs of the inbox parity proof (verified by the caller). The checkpoint's `in_hash` and
-    // `inbox_rolling_hash` are sourced from it, and its message sponge is checked against the blocks' accumulated one.
+    // Public inputs of the inbox parity proof (verified by the caller). The checkpoint's `inbox_rolling_hash` is
+    // sourced from it, and its message sponge is checked against the blocks' accumulated one.
     parity: ParityPublicInputs,
     // The below are all hints:
     previous_out_hash: AppendOnlyTreeSnapshot,
@@ -118,8 +118,8 @@ impl<let NumBlobs: u32> CheckpointRollupPublicInputsComposer<NumBlobs> {
             previous_out_hash: self.previous_out_hash,
             new_out_hash,
             // Sourced from the inbox parity proof (parity moved to the checkpoint root in AZIP-22 Fast Inbox), which
-            // commits to the same message list behind the L1-checked `in_hash`. Checkpoint merges assert continuity
-            // across checkpoints (`right.start == left.end`).
+            // commits to the checkpoint's message list. Checkpoint merges assert continuity across checkpoints
+            // (`right.start == left.end`).
             start_inbox_rolling_hash: self.parity.start_rolling_hash,
             end_inbox_rolling_hash: self.parity.end_rolling_hash,
             checkpoint_header_hashes,
@@ -146,10 +146,7 @@ impl<let NumBlobs: u32> CheckpointRollupPublicInputsComposer<NumBlobs> {
             last_archive_root: merged_rollup.previous_archive.root,
             block_headers_hash: merged_rollup.block_headers_hash,
             blobs_hash: self.blobs_hash,
-            // `in_hash` (the sha256 frontier root, checked on L1) and `inbox_rolling_hash` are sourced from the inbox
-            // parity proof. `in_hash` is an unconstrained pass-through there (see `ParityPublicInputs::in_hash`); it
-            // remains the authoritative L1 check until the Fast Inbox flip.
-            in_hash: self.parity.in_hash,
+            // Sourced from the inbox parity proof: the checkpoint's only inbox commitment (AZIP-22 Fast Inbox).
             inbox_rolling_hash: self.parity.end_rolling_hash,
             epoch_out_hash,
             slot_number: constants.slot_number,

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/mod.nr

@@ -154,17 +154,17 @@ impl TestBuilder {
         let start_block_number = fixture_builder.start_block_number;
         if !is_first_block(left_rollup_vk_index)
             & (left_rollup_vk_index != BLOCK_MERGE_ROLLUP_VK_INDEX) {
-            // Change the start_block_number to be smaller than the left rollup's start_block_number so that the in_hash
-            // won't be set on the left rollup.
+            // Change the start_block_number to be smaller than the left rollup's start_block_number so that the
+            // first-block designation is not on the left rollup.
             fixture_builder.start_block_number = start_block_number - 1;
         }
         let mut left_rollup = fixture_builder.get_merged_block_rollup_public_inputs(
             start_block_number,
             start_block_number + num_left_blocks - 1,
         );
         if is_first_block(right_rollup_vk_index) {
-            // Change the start_block_number to be the right rollup's start_block_number so that the in_hash will be set
-            // on the right rollup.
+            // Change the start_block_number to be the right rollup's start_block_number so that the first-block
+            // designation is on the right rollup.
             fixture_builder.start_block_number = start_block_number + num_left_blocks;
         }
         let mut right_rollup = fixture_builder.get_merged_block_rollup_public_inputs(
@@ -192,8 +192,8 @@ impl TestBuilder {
         left_rollup.start_state = hints.previous_block_header.state;
 
         // The InboxParity proof commits to the same checkpoint messages the block roots absorbed. Its message sponge
-        // (empty to the checkpoint's accumulated value) matches the blocks' merged sponge; its rolling hash and in_hash
-        // feed the checkpoint header. Built at the base slot the block fixtures use for their sponge.
+        // (empty to the checkpoint's accumulated value) matches the blocks' merged sponge; its rolling hash feeds the
+        // checkpoint header. Built at the base slot the block fixtures use for their sponge.
         let inbox_parity = fixture_builder.get_parity_public_inputs(fixture_builder.start_slot_number);
 
         Self {
@@ -445,7 +445,6 @@ impl TestBuilder {
             last_archive_root: left.previous_archive.root,
             block_headers_hash,
             blobs_hash: self.hints.blobs_hash,
-            in_hash: self.inbox_parity.in_hash,
             inbox_rolling_hash: self.inbox_parity.end_rolling_hash,
             epoch_out_hash,
             slot_number: left.constants.slot_number,

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/inbox_parity.nr

@@ -18,10 +18,6 @@ pub struct InboxParityPrivateInputs<let S: u32> {
     pub(crate) start_rolling_hash: Field,
     // Message-bundle sponge before this checkpoint's messages (empty at checkpoint start).
     pub(crate) start_sponge: L1ToL2MessageSponge,
-    // The L1 `in_hash` (sha256 frontier root of this checkpoint's messages), passed through UNCONSTRAINED to the
-    // public inputs. See `ParityPublicInputs::in_hash`: the frontier tree is gone from this body, so the prover
-    // supplies the value and the circuit does not recompute or bind it to `msgs`.
-    pub(crate) in_hash: Field,
     pub(crate) vk_tree_root: Field,
     pub(crate) prover_id: Field,
 }
@@ -35,7 +31,6 @@ pub struct InboxParityPrivateInputs<let S: u32> {
 /// - Absorbs the same real messages into the message sponge (real-count absorb; the checkpoint root asserts this
 ///   equals the sponge the block roots accumulate)
 /// - Asserts the padding lanes past `num_msgs` are zero so they cannot silently enter either accumulator
-/// - Passes `in_hash` through unconstrained (see `InboxParityPrivateInputs::in_hash`)
 ///
 /// The output feeds the Checkpoint Root circuits, which verify this proof against the `{64, 256, 1024}` VK ladder.
 ///
@@ -51,7 +46,6 @@ pub fn execute<let S: u32>(inputs: InboxParityPrivateInputs<S>) -> ParityPublicI
     end_sponge.absorb(inputs.msgs, inputs.num_msgs);
 
     ParityPublicInputs {
-        in_hash: inputs.in_hash,
         start_rolling_hash: inputs.start_rolling_hash,
         end_rolling_hash,
         start_sponge: inputs.start_sponge,

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr

@@ -18,14 +18,11 @@ fn public_inputs_match_expected() {
         num_msgs: S,
         start_rolling_hash: 0,
         start_sponge: L1ToL2MessageSponge::empty(),
-        in_hash: 0x1234,
         vk_tree_root: 42,
         prover_id: 7,
     };
     let public_inputs = inbox_parity::execute(private_inputs);
 
-    // `in_hash` is echoed through unconstrained.
-    assert_eq(public_inputs.in_hash, 0x1234);
     assert_eq(public_inputs.vk_tree_root, 42);
     assert_eq(public_inputs.prover_id, 7);
 
@@ -57,7 +54,6 @@ fn rolling_hash_and_sponge_ignore_padding_and_thread_start() {
         num_msgs: 3,
         start_rolling_hash: start,
         start_sponge,
-        in_hash: 0,
         vk_tree_root: 42,
         prover_id: 7,
     };
@@ -88,7 +84,6 @@ fn sponge_matches_block_root_real_count_absorb() {
         num_msgs: 2,
         start_rolling_hash: 0,
         start_sponge: L1ToL2MessageSponge::empty(),
-        in_hash: 0,
         vk_tree_root: 42,
         prover_id: 7,
     };
@@ -113,7 +108,6 @@ fn non_zero_padding_lane_fails() {
         num_msgs: 2,
         start_rolling_hash: 0,
         start_sponge: L1ToL2MessageSponge::empty(),
-        in_hash: 0,
         vk_tree_root: 42,
         prover_id: 7,
     };
@@ -127,7 +121,6 @@ fn num_msgs_greater_than_size_fails() {
         num_msgs: S + 1,
         start_rolling_hash: 0,
         start_sponge: L1ToL2MessageSponge::empty(),
-        in_hash: 0,
         vk_tree_root: 42,
         prover_id: 7,
     };

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/tests/rollup_fixture_builder.nr

@@ -43,7 +43,7 @@ pub struct RollupFixtureBuilder {
     pub protocol_contracts_hash: Field,
     pub prover_id: Field,
 
-    // Used to identify the first block, which will have an empty start_sponge_blob, and non-empty in_hash.
+    // Used to identify the first block, which will have an empty start_sponge_blob.
     pub start_block_number: u32,
 
     // Used to identify the first checkpoint, which will have an empty start_blob_accumulator.
@@ -425,7 +425,6 @@ impl RollupFixtureBuilder {
 
     pub fn get_parity_public_inputs(self, slot_number: Field) -> ParityPublicInputs {
         ParityPublicInputs {
-            in_hash: slot_number * 85831493,
             start_rolling_hash: self.get_inbox_rolling_hash(slot_number),
             end_rolling_hash: self.get_inbox_rolling_hash(slot_number + 1),
             // The message sponge resets per checkpoint, so it starts empty and ends at the checkpoint's accumulated

noir-projects/noir-protocol-circuits/crates/types/src/abis/checkpoint_header.nr

@@ -14,10 +14,9 @@ pub struct CheckpointHeader {
     pub last_archive_root: Field,
     pub block_headers_hash: Field,
     pub blobs_hash: Field,
-    pub in_hash: Field,
-    // Inbox rolling-hash chain value after consuming all L1-to-L2 messages bundled into this checkpoint. It is the
-    // dual of `in_hash` (AZIP-22 Fast Inbox): the truncated-to-field sha256 chain the L1 Inbox accumulates. Currently a
-    // pass-through commitment; `in_hash` remains the authoritative L1 check until the Fast Inbox flip.
+    // Inbox rolling-hash chain value after consuming all L1-to-L2 messages bundled into this checkpoint (AZIP-22 Fast
+    // Inbox): the truncated-to-field sha256 chain the L1 Inbox accumulates. This is the checkpoint's only inbox
+    // commitment.
     pub inbox_rolling_hash: Field,
     // The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
     // index 0, the second at index 1, and so on.
@@ -43,7 +42,6 @@ impl Empty for CheckpointHeader {
             last_archive_root: 0,
             block_headers_hash: 0,
             blobs_hash: 0,
-            in_hash: 0,
             inbox_rolling_hash: 0,
             epoch_out_hash: 0,
             slot_number: 0,
@@ -62,7 +60,6 @@ impl CheckpointHeader {
         let last_archive_root_bytes: [u8; 32] = self.last_archive_root.to_be_bytes();
         let block_headers_hash_bytes: [u8; 32] = self.block_headers_hash.to_be_bytes();
         let blobs_hash_bytes: [u8; 32] = self.blobs_hash.to_be_bytes();
-        let in_hash_bytes: [u8; 32] = self.in_hash.to_be_bytes();
         let inbox_rolling_hash_bytes: [u8; 32] = self.inbox_rolling_hash.to_be_bytes();
         let epoch_out_hash_bytes: [u8; 32] = self.epoch_out_hash.to_be_bytes();
         let slot_number_bytes: [u8; 32] = self.slot_number.to_be_bytes();
@@ -83,7 +80,6 @@ impl CheckpointHeader {
         last_archive_root_bytes
             .concat(block_headers_hash_bytes)
             .concat(blobs_hash_bytes)
-            .concat(in_hash_bytes)
             .concat(inbox_rolling_hash_bytes)
             .concat(epoch_out_hash_bytes)
             .concat(slot_number_bytes)
@@ -108,7 +104,7 @@ fn empty_checkpoint_header_hash_matches_ts() {
     let header = CheckpointHeader::empty();
 
     // Generated from checkpoint_header.test.ts
-    let empty_checkpoint_header_hash_from_ts = 0x0008c3e5bbea4fba57201a69d4bf70a0d255df921fdef4924c22da087f9338c2;
+    let empty_checkpoint_header_hash_from_ts = 0x002e384af86a480f952aa16443fd29646a9063865e62d7c403fc7ed697bb7712;
 
     assert_eq(header.hash(), empty_checkpoint_header_hash_from_ts);
 }
@@ -119,7 +115,6 @@ fn checkpoint_header_hash_matches_ts() {
         last_archive_root: 123,
         block_headers_hash: 456,
         blobs_hash: 77,
-        in_hash: 88,
         inbox_rolling_hash: 89,
         epoch_out_hash: 99,
         slot_number: 1234,
@@ -137,7 +132,7 @@ fn checkpoint_header_hash_matches_ts() {
     assert_eq(deserialized, header);
 
     // Generated from checkpoint_header.test.ts
-    let checkpoint_header_hash_from_ts = 0x00519b87177a8a5e4edd03f4d820aec6d402497ef1ab70e2ecd4d4c39b339611;
+    let checkpoint_header_hash_from_ts = 0x00751391e842cd7b2014478255dd3309df86327197a0feb03f0af1b758f62ba5;
 
     assert_eq(header.hash(), checkpoint_header_hash_from_ts);
 }
@@ -150,7 +145,6 @@ fn checkpoint_header_hash_large_values_matches_ts() {
         last_archive_root: MAX_FIELD_VALUE - 123,
         block_headers_hash: MAX_FIELD_VALUE - 456,
         blobs_hash: MAX_FIELD_VALUE - 77,
-        in_hash: MAX_FIELD_VALUE - 88,
         inbox_rolling_hash: MAX_FIELD_VALUE - 89,
         epoch_out_hash: MAX_FIELD_VALUE - 99,
         slot_number: MAX_FIELD_VALUE - 1234,
@@ -170,7 +164,7 @@ fn checkpoint_header_hash_large_values_matches_ts() {
     assert_eq(deserialized, header);
 
     // Generated from checkpoint_header.test.ts
-    let checkpoint_header_hash_large_values_from_ts = 0x00d64307fa93c32ae46a4c3b6a1911d31994daa8d11d50201f0086a6cbaa9bac;
+    let checkpoint_header_hash_large_values_from_ts = 0x005bd09725c6e77a4a28a7ccdaf7875ba5882431ca3c82e62db96e8a12769ce5;
 
     assert_eq(header.hash(), checkpoint_header_hash_large_values_from_ts);
 }

noir-projects/noir-protocol-circuits/crates/types/src/constants.nr

@@ -61,12 +61,10 @@ pub global NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 =
     NOTE_HASH_TREE_HEIGHT - NOTE_HASH_SUBTREE_HEIGHT;
 pub global NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 =
     NULLIFIER_TREE_HEIGHT - NULLIFIER_SUBTREE_HEIGHT;
-pub global L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 =
-    L1_TO_L2_MSG_TREE_HEIGHT - L1_TO_L2_MSG_SUBTREE_HEIGHT;
 // Cap on L1-to-L2 messages bundled into a single L2 block (AZIP-22 Fast Inbox). One quarter of the per-checkpoint
 // cap: a checkpoint drains its Inbox consumption across up to four message-bearing blocks.
 pub global MAX_L1_TO_L2_MSGS_PER_BLOCK: u32 = 256;
-// Cap on L1-to-L2 messages consumed by a single checkpoint. Semantically today's NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP.
+// Cap on L1-to-L2 messages consumed by a single checkpoint.
 pub global MAX_L1_TO_L2_MSGS_PER_CHECKPOINT: u32 = 1024;
 // Minimum bucket age, in seconds, at the start of a checkpoint's build frame for its consumption to be mandatory under
 // the streaming Inbox censorship cutoff (AZIP-22 Fast Inbox). One L1 slot: validators cannot be required to act on
@@ -109,9 +107,6 @@ pub global MAX_NULLIFIER_READ_REQUESTS_PER_CALL: u32 = 16;
 pub global MAX_KEY_VALIDATION_REQUESTS_PER_CALL: u32 = MAX_PRIVATE_LOGS_PER_CALL;
 // docs:end:constants
 
-// ROLLUP CONTRACT CONSTANTS - constants used only in l1-contracts
-pub global NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP: u32 = 1 << L1_TO_L2_MSG_SUBTREE_HEIGHT;
-
 // VK TREE CONSTANTS
 pub global PRIVATE_KERNEL_INIT_VK_INDEX: u32 = 0;
 pub global PRIVATE_KERNEL_INNER_VK_INDEX: u32 = 1;
@@ -453,7 +448,6 @@ pub global BLOCK_HEADER_LENGTH: u32 = APPEND_ONLY_TREE_SNAPSHOT_LENGTH
 pub global CHECKPOINT_HEADER_LENGTH: u32 = 1 /* last_archive_root */
     + 1 /* block_headers_hash */
     + 1 /* blobs_hash */
-    + 1 /* in_hash */
     + 1 /* inbox_rolling_hash */
     + 1 /* out_hash */
     + 1 /* slot_number */
@@ -675,12 +669,6 @@ pub global INBOX_PARITY_SIZE_SMALL: u32 = 64;
 pub global INBOX_PARITY_SIZE_MEDIUM: u32 = 256;
 pub global INBOX_PARITY_SIZE_LARGE: u32 = 1024;
 
-// Fan-in of the sha256 `in_hash` frontier tree (NUM_BASE_PARITY_PER_ROOT_PARITY * NUM_MSGS_PER_BASE_PARITY ==
-// NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP). The circuits no longer build this tree, but the constants are still consumed
-// by the generated Solidity `Constants` and the L1 `Parity.t.sol` test that checks the frontier-root construction.
-pub global NUM_MSGS_PER_BASE_PARITY: u32 = 256;
-pub global NUM_BASE_PARITY_PER_ROOT_PARITY: u32 = 4;
-
 // Lengths of the different types of proofs in fields
 pub global RECURSIVE_PROOF_LENGTH: u32 = 410;
 pub global NESTED_RECURSIVE_PROOF_LENGTH: u32 = RECURSIVE_PROOF_LENGTH;
@@ -1431,7 +1419,7 @@ mod test {
     use crate::traits::ToField;
     use super::{
         GLOBAL_INDEX_CONTRACT_MIN_REVERTIBLE_SIDE_EFFECT_COUNTER_OFFSET, INBOX_PARITY_SIZE_LARGE,
-        MAX_ETH_ADDRESS_VALUE, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+        MAX_ETH_ADDRESS_VALUE, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
         TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
     };
 
@@ -1478,7 +1466,7 @@ mod test {
     #[test]
     fn parity_covers_all_l1_to_l2_msgs() {
         // The largest InboxParity rung must be able to hold a full checkpoint's worth of messages.
-        assert_eq(INBOX_PARITY_SIZE_LARGE, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        assert_eq(INBOX_PARITY_SIZE_LARGE, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT);
     }
 
     #[test]

yarn-project/constants/src/constants.gen.ts

@@ -28,7 +28,6 @@ export const PUBLIC_DATA_SUBTREE_HEIGHT = 6;
 export const L1_TO_L2_MSG_SUBTREE_HEIGHT = 10;
 export const NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 36;
 export const NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 36;
-export const L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 26;
 export const MAX_L1_TO_L2_MSGS_PER_BLOCK = 256;
 export const MAX_L1_TO_L2_MSGS_PER_CHECKPOINT = 1024;
 export const INBOX_LAG_SECONDS = 12;
@@ -57,7 +56,6 @@ export const MAX_CONTRACT_CLASS_LOGS_PER_CALL = 1;
 export const MAX_NOTE_HASH_READ_REQUESTS_PER_CALL = 16;
 export const MAX_NULLIFIER_READ_REQUESTS_PER_CALL = 16;
 export const MAX_KEY_VALIDATION_REQUESTS_PER_CALL = 16;
-export const NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP = 1024;
 export const PRIVATE_KERNEL_INIT_VK_INDEX = 0;
 export const PRIVATE_KERNEL_INNER_VK_INDEX = 1;
 export const HIDING_KERNEL_TO_ROLLUP_VK_INDEX = 4;
@@ -218,8 +216,8 @@ export const TX_REQUEST_LENGTH = 15;
 export const TOTAL_FEES_LENGTH = 1;
 export const TOTAL_MANA_USED_LENGTH = 1;
 export const BLOCK_HEADER_LENGTH = 22;
-export const CHECKPOINT_HEADER_LENGTH = 14;
-export const CHECKPOINT_HEADER_SIZE_IN_BYTES = 380;
+export const CHECKPOINT_HEADER_LENGTH = 13;
+export const CHECKPOINT_HEADER_SIZE_IN_BYTES = 348;
 export const SCOPED_READ_REQUEST_LEN = 3;
 export const PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 839;
 export const PRIVATE_CONTEXT_INPUTS_LENGTH = 38;
@@ -253,8 +251,6 @@ export const ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH = 113;
 export const INBOX_PARITY_SIZE_SMALL = 64;
 export const INBOX_PARITY_SIZE_MEDIUM = 256;
 export const INBOX_PARITY_SIZE_LARGE = 1024;
-export const NUM_MSGS_PER_BASE_PARITY = 256;
-export const NUM_BASE_PARITY_PER_ROOT_PARITY = 4;
 export const RECURSIVE_PROOF_LENGTH = 410;
 export const NESTED_RECURSIVE_PROOF_LENGTH = 410;
 export const IPA_PROOF_LENGTH = 64;