genesis_generation_tests.rs
1 // Copyright (c) 2025-2026 ACDC Network 2 // This file is part of the alphaos library. 3 // 4 // Alpha Chain | Delta Chain Protocol 5 // International Monetary Graphite. 6 // 7 // Derived from Aleo (https://aleo.org) and ProvableHQ (https://provable.com). 8 // They built world-class ZK infrastructure. We installed the EASY button. 9 // Their cryptography: elegant. Our modifications: bureaucracy-compatible. 10 // Original brilliance: theirs. Robert's Rules: ours. Bugs: definitely ours. 11 // 12 // Original Aleo/ProvableHQ code subject to Apache 2.0 https://www.apache.org/licenses/LICENSE-2.0 13 // All modifications and new work: CC0 1.0 Universal Public Domain Dedication. 14 // No rights reserved. No permission required. No warranty. No refunds. 15 // 16 // https://creativecommons.org/publicdomain/zero/1.0/ 17 // SPDX-License-Identifier: CC0-1.0 18 19 // Integration tests for dual-chain genesis generation (Section 10) 20 21 use super::*; 22 use anyhow::Result; 23 24 #[cfg(test)] 25 mod tests { 26 use super::*; 27 28 #[test] 29 fn test_load_alpha_params_not_found() { 30 // Should fail gracefully when params don't exist 31 let result = load_alpha_params("nonexistent_hash"); 32 assert!(result.is_err()); 33 assert!(result.unwrap_err().to_string().contains("not found")); 34 } 35 36 #[test] 37 fn test_load_delta_params_not_found() { 38 let result = load_delta_params("nonexistent_hash"); 39 assert!(result.is_err()); 40 assert!(result.unwrap_err().to_string().contains("not found")); 41 } 42 43 #[test] 44 fn test_cache_alpha_params() -> Result<()> { 45 let params = AlphaGenesisParams { 46 network_id: 1, 47 timestamp: 1735700000, 48 committee: vec!["ax1test1".to_string()], 49 initial_balances: vec![("ax1test1".to_string(), 1_000_000_000_000)], 50 programs: vec![], 51 proof_target: 1000, 52 coinbase_target: 5000, 53 expected_hash: "test_alpha_cache".to_string(), 54 }; 55 56 // Cache the params 57 cache_alpha_params(¶ms, "test_alpha_cache")?; 58 59 // Load them back 60 let loaded = load_alpha_params("test_alpha_cache")?; 61 assert_eq!(loaded.network_id, 1); 62 assert_eq!(loaded.committee.len(), 1); 63 64 Ok(()) 65 } 66 67 #[test] 68 fn test_cache_delta_params() -> Result<()> { 69 let params = DeltaGenesisParams { 70 network_id: 1, 71 timestamp: 1735700000, 72 committee: vec!["dx1test1".to_string()], 73 initial_balances: vec![], 74 programs: vec![], 75 proof_target: 1000, 76 coinbase_target: 5000, 77 alpha_genesis_hash: "ab0000000000".to_string(), 78 alpha_genesis_height: 0, 79 alpha_state_root: "sr0000000000".to_string(), 80 expected_hash: "test_delta_cache".to_string(), 81 }; 82 83 // Cache the params 84 cache_delta_params(¶ms, "test_delta_cache")?; 85 86 // Load them back 87 let loaded = load_delta_params("test_delta_cache")?; 88 assert_eq!(loaded.network_id, 1); 89 assert_eq!(loaded.alpha_genesis_hash, "ab0000000000"); 90 91 Ok(()) 92 } 93 94 #[test] 95 fn test_dual_chain_genesis_coordination() -> Result<()> { 96 // Test that Delta params correctly reference Alpha genesis 97 98 let alpha_params = AlphaGenesisParams { 99 network_id: 0, 100 timestamp: 1735700000, 101 committee: vec!["ax1gov1".to_string(), "ax1gov2".to_string()], 102 initial_balances: vec![], 103 programs: vec![], 104 proof_target: 1000, 105 coinbase_target: 5000, 106 expected_hash: "alpha_genesis_abc123".to_string(), 107 }; 108 109 let delta_params = DeltaGenesisParams { 110 network_id: 0, 111 timestamp: 1735700100, // 100 seconds after Alpha 112 committee: alpha_params.committee.clone(), // Same committee 113 initial_balances: vec![], 114 programs: vec![], 115 proof_target: 1000, 116 coinbase_target: 5000, 117 alpha_genesis_hash: alpha_params.expected_hash.clone(), 118 alpha_genesis_height: 0, 119 alpha_state_root: "sr_test_123".to_string(), 120 expected_hash: "delta_genesis_def456".to_string(), 121 }; 122 123 // Verify cross-references are correct 124 assert_eq!(delta_params.alpha_genesis_hash, alpha_params.expected_hash); 125 assert_eq!(delta_params.committee, alpha_params.committee); 126 assert!(delta_params.timestamp > alpha_params.timestamp); 127 128 Ok(()) 129 } 130 131 #[test] 132 fn test_params_serialization_roundtrip() -> Result<()> { 133 let alpha_params = AlphaGenesisParams { 134 network_id: 1, 135 timestamp: 1735700000, 136 committee: vec!["ax1test1".to_string(), "ax1test2".to_string(), "ax1test3".to_string()], 137 initial_balances: vec![ 138 ("ax1test1".to_string(), 1_000_000_000_000), 139 ("ax1test2".to_string(), 500_000_000_000), 140 ], 141 programs: vec![ 142 ("credits.alpha".to_string(), vec![1, 2, 3]), 143 ("governance.alpha".to_string(), vec![4, 5, 6]), 144 ], 145 proof_target: 1000, 146 coinbase_target: 5000, 147 expected_hash: "test_roundtrip_123".to_string(), 148 }; 149 150 // Serialize to JSON 151 let json = serde_json::to_string(&alpha_params)?; 152 153 // Deserialize back 154 let parsed: AlphaGenesisParams = serde_json::from_str(&json)?; 155 156 // Verify all fields match 157 assert_eq!(parsed.network_id, alpha_params.network_id); 158 assert_eq!(parsed.timestamp, alpha_params.timestamp); 159 assert_eq!(parsed.committee, alpha_params.committee); 160 assert_eq!(parsed.initial_balances, alpha_params.initial_balances); 161 assert_eq!(parsed.programs, alpha_params.programs); 162 assert_eq!(parsed.proof_target, alpha_params.proof_target); 163 assert_eq!(parsed.expected_hash, alpha_params.expected_hash); 164 165 Ok(()) 166 } 167 168 #[test] 169 fn test_network_upgrade_scenario() -> Result<()> { 170 // Simulate a complete network upgrade scenario: 171 // 1. Load Alpha params 172 // 2. Generate Alpha genesis 173 // 3. Wait for Alpha stability 174 // 4. Load Delta params with Alpha references 175 // 5. Generate Delta genesis 176 177 // Step 1: Create and cache Alpha params 178 let alpha_params = AlphaGenesisParams { 179 network_id: 0, 180 timestamp: 1735700000, 181 committee: vec!["ax1gov1".to_string(), "ax1gov2".to_string()], 182 initial_balances: vec![("ax1treasury".to_string(), 10_000_000_000_000)], 183 programs: vec![], 184 proof_target: 1000, 185 coinbase_target: 5000, 186 expected_hash: "test_upgrade_alpha".to_string(), 187 }; 188 189 cache_alpha_params(&alpha_params, "test_upgrade_alpha")?; 190 let loaded_alpha = load_alpha_params("test_upgrade_alpha")?; 191 assert_eq!(loaded_alpha.network_id, 0); 192 193 // Step 2: Create Delta params referencing Alpha 194 let delta_params = DeltaGenesisParams { 195 network_id: 0, 196 timestamp: 1735700100, 197 committee: alpha_params.committee.clone(), 198 initial_balances: vec![], 199 programs: vec![], 200 proof_target: 1000, 201 coinbase_target: 5000, 202 alpha_genesis_hash: "test_upgrade_alpha".to_string(), 203 alpha_genesis_height: 0, 204 alpha_state_root: "sr_after_stability".to_string(), 205 expected_hash: "test_upgrade_delta".to_string(), 206 }; 207 208 cache_delta_params(&delta_params, "test_upgrade_delta")?; 209 let loaded_delta = load_delta_params("test_upgrade_delta")?; 210 211 // Verify the upgrade scenario is consistent 212 assert_eq!(loaded_delta.committee, loaded_alpha.committee); 213 assert_eq!(loaded_delta.network_id, loaded_alpha.network_id); 214 assert!(loaded_delta.timestamp > loaded_alpha.timestamp); 215 216 Ok(()) 217 } 218 }