feat(applying): include main constants in pparams (#565)

pallas-applying/Cargo.toml

@@ -20,6 +20,7 @@ pallas-primitives = { version = "=0.31.0", path = "../pallas-primitives" }
 pallas-traverse = { version = "=0.31.0", path = "../pallas-traverse" }
 rand = "0.8"
 hex = "0.4"
+chrono = "0.4.39"
 
 [dev-dependencies]
 hex = "0.4"

pallas-applying/src/utils/environment.rs

@@ -21,6 +21,28 @@ pub enum MultiEraProtocolParameters {
 }
 
 impl MultiEraProtocolParameters {
+    pub fn system_start(&self) -> chrono::DateTime<chrono::FixedOffset> {
+        match self {
+            MultiEraProtocolParameters::Byron(ByronProtParams { start_time, .. }) => {
+                chrono::DateTime::from_timestamp(*start_time as i64, 0)
+                    .expect("valid timestamp")
+                    .fixed_offset()
+            }
+            MultiEraProtocolParameters::Shelley(ShelleyProtParams { system_start, .. }) => {
+                *system_start
+            }
+            MultiEraProtocolParameters::Alonzo(AlonzoProtParams { system_start, .. }) => {
+                *system_start
+            }
+            MultiEraProtocolParameters::Babbage(BabbageProtParams { system_start, .. }) => {
+                *system_start
+            }
+            MultiEraProtocolParameters::Conway(ConwayProtParams { system_start, .. }) => {
+                *system_start
+            }
+        }
+    }
+
     pub fn protocol_version(&self) -> usize {
         match self {
             MultiEraProtocolParameters::Byron(ByronProtParams {
@@ -45,11 +67,56 @@ impl MultiEraProtocolParameters {
             }) => *x as usize,
         }
     }
+
+    const FIVE_DAYS_IN_SECONDS: u64 = 5 * 24 * 60 * 60;
+
+    pub fn epoch_length(&self) -> u64 {
+        match self {
+            MultiEraProtocolParameters::Byron(ByronProtParams { slot_duration, .. }) => {
+                // TODO: research if Byron epoch length is actually hardcoded or if you can get
+                // it from genesis files somehow
+                Self::FIVE_DAYS_IN_SECONDS / (*slot_duration / 1000)
+            }
+            MultiEraProtocolParameters::Shelley(ShelleyProtParams { epoch_length, .. }) => {
+                *epoch_length
+            }
+            MultiEraProtocolParameters::Alonzo(AlonzoProtParams { epoch_length, .. }) => {
+                *epoch_length
+            }
+            MultiEraProtocolParameters::Babbage(BabbageProtParams { epoch_length, .. }) => {
+                *epoch_length
+            }
+            MultiEraProtocolParameters::Conway(ConwayProtParams { epoch_length, .. }) => {
+                *epoch_length
+            }
+        }
+    }
+
+    pub fn slot_length(&self) -> u64 {
+        match self {
+            MultiEraProtocolParameters::Byron(ByronProtParams { slot_duration, .. }) => {
+                *slot_duration / 1000
+            }
+            MultiEraProtocolParameters::Shelley(ShelleyProtParams { slot_length, .. }) => {
+                *slot_length
+            }
+            MultiEraProtocolParameters::Alonzo(AlonzoProtParams { slot_length, .. }) => {
+                *slot_length
+            }
+            MultiEraProtocolParameters::Babbage(BabbageProtParams { slot_length, .. }) => {
+                *slot_length
+            }
+            MultiEraProtocolParameters::Conway(ConwayProtParams { slot_length, .. }) => {
+                *slot_length
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub struct ByronProtParams {
     pub block_version: (u16, u16, u8),
+    pub start_time: u64,
     pub script_version: u16,
     pub slot_duration: u64,
     pub max_block_size: u64,
@@ -69,6 +136,9 @@ pub struct ByronProtParams {
 
 #[derive(Debug, Clone)]
 pub struct ShelleyProtParams {
+    pub system_start: chrono::DateTime<chrono::FixedOffset>,
+    pub epoch_length: u64,
+    pub slot_length: u64,
     pub minfee_a: u32,
     pub minfee_b: u32,
     pub max_block_body_size: u32,
@@ -90,6 +160,9 @@ pub struct ShelleyProtParams {
 
 #[derive(Debug, Clone)]
 pub struct AlonzoProtParams {
+    pub system_start: chrono::DateTime<chrono::FixedOffset>,
+    pub epoch_length: u64,
+    pub slot_length: u64,
     pub minfee_a: u32,
     pub minfee_b: u32,
     pub max_block_body_size: u32,
@@ -118,6 +191,9 @@ pub struct AlonzoProtParams {
 
 #[derive(Debug, Clone)]
 pub struct BabbageProtParams {
+    pub system_start: chrono::DateTime<chrono::FixedOffset>,
+    pub epoch_length: u64,
+    pub slot_length: u64,
     pub minfee_a: u32,
     pub minfee_b: u32,
     pub max_block_body_size: u32,
@@ -146,6 +222,9 @@ pub struct BabbageProtParams {
 
 #[derive(Debug, Clone)]
 pub struct ConwayProtParams {
+    pub system_start: chrono::DateTime<chrono::FixedOffset>,
+    pub epoch_length: u64,
+    pub slot_length: u64,
     pub minfee_a: u32,
     pub minfee_b: u32,
     pub max_block_body_size: u32,

pallas-applying/tests/alonzo.rs

@@ -2558,6 +2558,9 @@ mod alonzo_tests {
 
     fn mk_params_epoch_334() -> AlonzoProtParams {
         AlonzoProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2017-09-23T21:44:51Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 65536,
@@ -2633,6 +2636,9 @@ mod alonzo_tests {
 
     fn mk_params_epoch_300() -> AlonzoProtParams {
         AlonzoProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2017-09-23T21:44:51Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 81920,

pallas-applying/tests/babbage.rs

@@ -2369,6 +2369,9 @@ mod babbage_tests {
 
     fn mk_mainnet_params_epoch_365() -> BabbageProtParams {
         BabbageProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2017-09-23T21:44:51Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 90112,
@@ -2445,6 +2448,9 @@ mod babbage_tests {
 
     fn mk_mainnet_params_epoch_380() -> BabbageProtParams {
         BabbageProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2022-10-25T00:00:00Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 90112,
@@ -2697,6 +2703,9 @@ mod babbage_tests {
 
     fn mk_preview_params_epoch_30() -> BabbageProtParams {
         BabbageProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2022-10-25T00:00:00Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 90112,
@@ -2787,6 +2796,9 @@ mod babbage_tests {
 
     fn mk_preprod_params_epoch_100() -> BabbageProtParams {
         BabbageProtParams {
+            system_start: chrono::DateTime::parse_from_rfc3339("2017-09-23T21:44:51Z").unwrap(),
+            epoch_length: 432000,
+            slot_length: 1,
             minfee_a: 44,
             minfee_b: 155381,
             max_block_body_size: 90112,

pallas-applying/tests/byron.rs

@@ -24,6 +24,45 @@ use std::vec::Vec;
 mod byron_tests {
     use super::*;
 
+    macro_rules! hardcoded_environment_values {
+        ($($key:ident = $value:expr),*) => {
+            {
+                #[allow(unused_mut)]
+                let mut pparams = ByronProtParams {
+                    block_version: (1, 0, 0),
+                    start_time: 1506203091,
+                    script_version: 0,
+                    slot_duration: 20000,
+                    max_block_size: 2000000,
+                    max_header_size: 2000000,
+                    max_tx_size: 4096,
+                    max_proposal_size: 700,
+                    mpc_thd: 20000000000000,
+                    heavy_del_thd: 300000000000,
+                    update_vote_thd: 1000000000000,
+                    update_proposal_thd: 100000000000000,
+                    update_implicit: 10000,
+                    soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
+                    summand: 155381,
+                    multiplier: 44,
+                    unlock_stake_epoch: 18446744073709551615,
+                };
+
+                $(
+                    pparams.$key = $value;
+                )*
+
+                Environment {
+                    prot_params: MultiEraProtocolParameters::Byron(pparams),
+                    prot_magic: 764824073,
+                    block_slot: 6341,
+                    network_id: 1,
+                    acnt: None,
+                }
+            }
+        }
+    }
+
     #[test]
     // Transaction hash:
     // a9e4413a5fb61a7a43c7df006ffcaaf3f2ffc9541f54757023968c5a8f8294fd
@@ -38,30 +77,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 6341,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => (),
@@ -83,30 +99,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => (),
@@ -136,30 +129,7 @@ mod byron_tests {
         };
         mtxp.transaction = Decode::decode(&mut Decoder::new(tx_buf.as_slice()), &mut ()).unwrap();
         let metx: MultiEraTx = MultiEraTx::from_byron(&mtxp);
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("Inputs set should not be empty"),
@@ -192,30 +162,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("Outputs set should not be empty"),
@@ -233,30 +180,7 @@ mod byron_tests {
         let mtxp: MintedTxPayload = minted_tx_payload_from_cbor(&cbor_bytes);
         let metx: MultiEraTx = MultiEraTx::from_byron(&mtxp);
         let utxos: UTxOs = UTxOs::new();
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("All inputs must be within the UTxO set"),
@@ -295,30 +219,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("All outputs must contain lovelace"),
@@ -342,30 +243,8 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
+        let env: Environment = hardcoded_environment_values!(summand = 1000, multiplier = 1000);
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 1000,
-                multiplier: 1000,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("Fees should not be below minimum"),
@@ -389,30 +268,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!(max_tx_size = 0);
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 0,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("Transaction size cannot exceed protocol limit"),
@@ -444,30 +300,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("All inputs must have a witness signature"),
@@ -508,30 +341,7 @@ mod byron_tests {
                 19999000000,
             )],
         );
-        let env: Environment = Environment {
+        let env: Environment = hardcoded_environment_values!();
-            prot_params: MultiEraProtocolParameters::Byron(ByronProtParams {
-                block_version: (1, 0, 0),
-                script_version: 0,
-                slot_duration: 20000,
-                max_block_size: 2000000,
-                max_header_size: 2000000,
-                max_tx_size: 4096,
-                max_proposal_size: 700,
-                mpc_thd: 20000000000000,
-                heavy_del_thd: 300000000000,
-                update_vote_thd: 1000000000000,
-                update_proposal_thd: 100000000000000,
-                update_implicit: 10000,
-                soft_fork_rule: (900000000000000, 600000000000000, 50000000000000),
-                summand: 155381,
-                multiplier: 44,
-                unlock_stake_epoch: 18446744073709551615,
-            }),
-            prot_magic: 764824073,
-            block_slot: 3241381,
-            network_id: 1,
-            acnt: None,
-        };
         let mut cert_state: CertState = CertState::default();
         match validate_txs(&[metx], &env, &utxos, &mut cert_state) {
             Ok(()) => panic!("Witness signature should verify the transaction"),