Add missing header type + conversions

types/src/v0/impls/header.rs

@@ -329,7 +329,7 @@ impl Header {
                 builder_signature: builder_signature.first().copied(),
             }),
             3 => Self::V3(v0_3::Header {
-                chain_config: v0_1::ResolvableChainConfig::from(v0_1::ChainConfig::from(
+                chain_config: v0_3::ResolvableChainConfig::from(v0_3::ChainConfig::from(
                     chain_config,
                 )),
                 height,
@@ -550,7 +550,7 @@ impl Header {
                 builder_signature: builder_signature.first().copied(),
             }),
             3 => Self::V3(v0_3::Header {
-                chain_config: v0_1::ResolvableChainConfig::from(v0_1::ChainConfig::from(
+                chain_config: v0_3::ResolvableChainConfig::from(v0_3::ChainConfig::from(
                     chain_config,
                 )),
                 height,

types/src/v0/v0_3/chain_config.rs

@@ -1,4 +1,4 @@
-use crate::{v0_1, BlockSize, ChainId, FeeAccount, FeeAmount};
+use crate::{v0_1, v0_99, BlockSize, ChainId, FeeAccount, FeeAmount};
 use committable::{Commitment, Committable};
 use ethers::types::{Address, U256};
 use itertools::Either;
@@ -74,13 +74,13 @@ impl Committable for ChainConfig {
 }
 
 impl ResolvableChainConfig {
-    pub fn _commit(&self) -> Commitment<ChainConfig> {
+    pub fn commit(&self) -> Commitment<ChainConfig> {
         match self.chain_config {
             Either::Left(config) => config.commit(),
             Either::Right(commitment) => commitment,
         }
     }
-    pub fn _resolve(self) -> Option<ChainConfig> {
+    pub fn resolve(self) -> Option<ChainConfig> {
         match self.chain_config {
             Either::Left(config) => Some(config),
             Either::Right(_) => None,
@@ -141,23 +141,25 @@ impl From<v0_1::ChainConfig> for ChainConfig {
     }
 }
 
-impl From<ChainConfig> for v0_1::ChainConfig {
-    fn from(chain_config: ChainConfig) -> v0_1::ChainConfig {
-        let ChainConfig {
+impl From<v0_99::ChainConfig> for ChainConfig {
+    fn from(chain_config: v0_99::ChainConfig) -> ChainConfig {
+        let v0_99::ChainConfig {
             chain_id,
             max_block_size,
             base_fee,
             fee_contract,
             fee_recipient,
+            stake_table_contract,
             ..
         } = chain_config;
 
-        v0_1::ChainConfig {
+        ChainConfig {
             chain_id,
             max_block_size,
             base_fee,
             fee_contract,
             fee_recipient,
+            stake_table_contract,
         }
     }
 }

types/src/v0/v0_3/header.rs

@@ -0,0 +1,61 @@
+use crate::NsTable;
+
+use super::{
+    BlockMerkleCommitment, BuilderSignature, FeeInfo, FeeMerkleCommitment, L1BlockInfo,
+    ResolvableChainConfig,
+};
+use ark_serialize::CanonicalSerialize;
+use committable::{Commitment, Committable, RawCommitmentBuilder};
+use hotshot_types::{utils::BuilderCommitment, vid::VidCommitment};
+use serde::{Deserialize, Serialize};
+
+/// A header is like a [`Block`] with the body replaced by a digest.
+#[derive(Clone, Debug, Deserialize, Serialize, Hash, PartialEq, Eq)]
+pub struct Header {
+    /// A commitment to a ChainConfig or a full ChainConfig.
+    pub(crate) chain_config: ResolvableChainConfig,
+    pub(crate) height: u64,
+    pub(crate) timestamp: u64,
+    pub(crate) l1_head: u64,
+    pub(crate) l1_finalized: Option<L1BlockInfo>,
+    pub(crate) payload_commitment: VidCommitment,
+    pub(crate) builder_commitment: BuilderCommitment,
+    pub(crate) ns_table: NsTable,
+    pub(crate) block_merkle_tree_root: BlockMerkleCommitment,
+    pub(crate) fee_merkle_tree_root: FeeMerkleCommitment,
+    pub(crate) fee_info: FeeInfo,
+    pub(crate) builder_signature: Option<BuilderSignature>,
+}
+
+impl Committable for Header {
+    fn commit(&self) -> Commitment<Self> {
+        let mut bmt_bytes = vec![];
+        self.block_merkle_tree_root
+            .serialize_with_mode(&mut bmt_bytes, ark_serialize::Compress::Yes)
+            .unwrap();
+        let mut fmt_bytes = vec![];
+        self.fee_merkle_tree_root
+            .serialize_with_mode(&mut fmt_bytes, ark_serialize::Compress::Yes)
+            .unwrap();
+
+        RawCommitmentBuilder::new(&Self::tag())
+            .field("chain_config", self.chain_config.commit())
+            .u64_field("height", self.height)
+            .u64_field("timestamp", self.timestamp)
+            .u64_field("l1_head", self.l1_head)
+            .optional("l1_finalized", &self.l1_finalized)
+            .constant_str("payload_commitment")
+            .fixed_size_bytes(self.payload_commitment.as_ref().as_ref())
+            .constant_str("builder_commitment")
+            .fixed_size_bytes(self.builder_commitment.as_ref())
+            .field("ns_table", self.ns_table.commit())
+            .var_size_field("block_merkle_tree_root", &bmt_bytes)
+            .var_size_field("fee_merkle_tree_root", &fmt_bytes)
+            .field("fee_info", self.fee_info.commit())
+            .finalize()
+    }
+
+    fn tag() -> String {
+        crate::v0_1::Header::tag()
+    }
+}

types/src/v0/v0_3/mod.rs

@@ -4,14 +4,13 @@ use vbs::version::Version;
 pub use super::v0_1::{
     AccountQueryData, BlockMerkleCommitment, BlockMerkleTree, BlockSize, BuilderSignature, ChainId,
     Delta, FeeAccount, FeeAccountProof, FeeAmount, FeeInfo, FeeMerkleCommitment, FeeMerkleProof,
-    FeeMerkleTree, Header, Index, Iter, L1BlockInfo, L1Client, L1ClientOptions, L1Snapshot,
-    NamespaceId, NsIndex, NsIter, NsPayload, NsPayloadBuilder, NsPayloadByteLen, NsPayloadOwned,
-    NsPayloadRange, NsProof, NsTable, NsTableBuilder, NsTableValidationError, NumNss, NumTxs,
-    NumTxsRange, NumTxsUnchecked, Payload, PayloadByteLen, ResolvableChainConfig, TimeBasedUpgrade,
-    Transaction, TxIndex, TxIter, TxPayload, TxPayloadRange, TxProof, TxTableEntries,
-    TxTableEntriesRange, Upgrade, UpgradeMode, UpgradeType, ViewBasedUpgrade,
-    BLOCK_MERKLE_TREE_HEIGHT, FEE_MERKLE_TREE_HEIGHT, NS_ID_BYTE_LEN, NS_OFFSET_BYTE_LEN,
-    NUM_NSS_BYTE_LEN, NUM_TXS_BYTE_LEN, TX_OFFSET_BYTE_LEN,
+    FeeMerkleTree, Index, Iter, L1BlockInfo, L1Client, L1ClientOptions, L1Snapshot, NamespaceId,
+    NsIndex, NsIter, NsPayload, NsPayloadBuilder, NsPayloadByteLen, NsPayloadOwned, NsPayloadRange,
+    NsProof, NsTable, NsTableBuilder, NsTableValidationError, NumNss, NumTxs, NumTxsRange,
+    NumTxsUnchecked, Payload, PayloadByteLen, TimeBasedUpgrade, Transaction, TxIndex, TxIter,
+    TxPayload, TxPayloadRange, TxProof, TxTableEntries, TxTableEntriesRange, Upgrade, UpgradeMode,
+    UpgradeType, ViewBasedUpgrade, BLOCK_MERKLE_TREE_HEIGHT, FEE_MERKLE_TREE_HEIGHT,
+    NS_ID_BYTE_LEN, NS_OFFSET_BYTE_LEN, NUM_NSS_BYTE_LEN, NUM_TXS_BYTE_LEN, TX_OFFSET_BYTE_LEN,
 };
 pub(crate) use super::v0_1::{
     L1ClientMetrics, L1Event, L1Provider, L1State, L1UpdateTask, MultiRpcClient,
@@ -21,7 +20,9 @@ pub(crate) use super::v0_1::{
 pub const VERSION: Version = Version { major: 0, minor: 3 };
 
 mod chain_config;
+mod header;
 mod stake_table;
 
 pub use chain_config::*;
+pub use header::Header;
 pub use stake_table::*;

types/src/v0/v0_99/chain_config.rs

@@ -130,6 +130,21 @@ impl From<&v0_1::ResolvableChainConfig> for ResolvableChainConfig {
     }
 }
 
+impl From<&v0_3::ResolvableChainConfig> for ResolvableChainConfig {
+    fn from(
+        &v0_3::ResolvableChainConfig { chain_config }: &v0_3::ResolvableChainConfig,
+    ) -> ResolvableChainConfig {
+        match chain_config {
+            Either::Left(chain_config) => ResolvableChainConfig {
+                chain_config: Either::Left(ChainConfig::from(chain_config)),
+            },
+            Either::Right(c) => ResolvableChainConfig {
+                chain_config: Either::Right(Commitment::from_raw(*c.as_ref())),
+            },
+        }
+    }
+}
+
 impl From<v0_1::ChainConfig> for ChainConfig {
     fn from(chain_config: v0_1::ChainConfig) -> ChainConfig {
         let v0_1::ChainConfig {
@@ -217,22 +232,44 @@ mod test {
     use super::*;
 
     #[test]
-    fn test_upgrade_chain_config_v3_resolvable_chain_config_from_v1() {
+    fn test_upgrade_chain_config_v99_resolvable_chain_config_from_v1() {
         let expectation: ResolvableChainConfig = ChainConfig::default().into();
         let v1_resolvable: v0_1::ResolvableChainConfig = v0_1::ChainConfig::default().into();
-        let v3_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v1_resolvable);
-        assert_eq!(expectation, v3_resolvable);
+        let v99_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v1_resolvable);
+        assert_eq!(expectation, v99_resolvable);
         let expectation: ResolvableChainConfig = ChainConfig::default().commit().into();
         let v1_resolvable: v0_1::ResolvableChainConfig =
             v0_1::ChainConfig::default().commit().into();
-        let v3_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v1_resolvable);
-        assert_eq!(expectation, v3_resolvable);
+        let v99_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v1_resolvable);
+        assert_eq!(expectation, v99_resolvable);
     }
+
     #[test]
-    fn test_upgrade_chain_config_v1_chain_config_from_v3() {
+    fn test_upgrade_chain_config_v99_resolvable_chain_config_from_v3() {
+        let expectation: ResolvableChainConfig = ChainConfig::default().into();
+        let v3_resolvable: v0_3::ResolvableChainConfig = v0_3::ChainConfig::default().into();
+        let v99_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v3_resolvable);
+        assert_eq!(expectation, v99_resolvable);
+        let expectation: ResolvableChainConfig = ChainConfig::default().commit().into();
+        let v3_resolvable: v0_3::ResolvableChainConfig =
+            v0_3::ChainConfig::default().commit().into();
+        let v99_resolvable: ResolvableChainConfig = ResolvableChainConfig::from(&v3_resolvable);
+        assert_eq!(expectation, v99_resolvable);
+    }
+
+    #[test]
+    fn test_upgrade_chain_config_v1_chain_config_from_v99() {
         let expectation = v0_1::ChainConfig::default();
-        let v3_chain_config = ChainConfig::default();
-        let v1_chain_config = v0_1::ChainConfig::from(v3_chain_config);
+        let v99_chain_config = ChainConfig::default();
+        let v1_chain_config = v0_1::ChainConfig::from(v99_chain_config);
         assert_eq!(expectation, v1_chain_config);
     }
+
+    #[test]
+    fn test_upgrade_chain_config_v3_chain_config_from_v99() {
+        let expectation = v0_3::ChainConfig::default();
+        let v99_chain_config = ChainConfig::default();
+        let v3_chain_config = v0_3::ChainConfig::from(v99_chain_config);
+        assert_eq!(expectation, v3_chain_config);
+    }
 }