diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/mod.rs index 5ba3ac81174..36279aad809 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/mod.rs @@ -1,5 +1,6 @@ mod update_state_masternode_list; mod v0; +mod v1; use crate::error::execution::ExecutionError; use crate::error::Error; @@ -60,9 +61,18 @@ where transaction, platform_version, ), + 1 => self.update_masternode_list_v1( + platform_state, + block_platform_state, + core_block_height, + is_init_chain, + block_info, + transaction, + platform_version, + ), version => Err(Error::Execution(ExecutionError::UnknownVersionMismatch { method: "update_masternode_list".to_string(), - known_versions: vec![0], + known_versions: vec![0, 1], received: version, })), } @@ -78,20 +88,30 @@ mod test { }; use crate::platform_types::platform_state::PlatformStateV0Methods; use crate::platform_types::validator::v0::{NewValidatorIfMasternodeInState, ValidatorV0}; + use crate::platform_types::validator_set::v0::ValidatorSetV0Getters; + use crate::platform_types::validator_set::{ValidatorSet, ValidatorSetExt}; use crate::rpc::core::MockCoreRPCLike; use crate::test::helpers::setup::{TempPlatform, TestPlatformBuilder}; + use dpp::bls_signatures::{Bls12381G2Impl, SecretKey}; + use dpp::core_types::validator_set::v0::ValidatorSetV0; use dpp::dashcore::hashes::Hash; - use dpp::dashcore::ProTxHash; - use dpp::dashcore_rpc::json::MasternodeListDiff; + use dpp::dashcore::{Network, ProTxHash, PubkeyHash, QuorumHash}; + use dpp::dashcore_rpc::json::{ + DMNStateDiff, MasternodeListDiff, MasternodeListItem, MasternodeType, + }; use dpp::identifier::MasternodeIdentifiers; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{KeyID, Purpose}; use dpp::prelude::Identifier; - use std::collections::BTreeMap; + use rand::rngs::StdRng; + use rand::SeedableRng; + use serde_json::{json, Value}; + use std::collections::{BTreeMap, BTreeSet}; use std::env; use std::fs::File; use std::io::BufReader; + use std::net::SocketAddr; use std::path::PathBuf; use std::str::FromStr; @@ -214,6 +234,329 @@ mod test { .expect("expected to commit"); } + /// A `protx listdiff` response from the mainnet fixtures. With + /// `core_23_addresses`, every masternode and diff also lists the + /// `addresses` Core 23 prints beside the legacy fields. `evonodes` + /// collects the ProTx hashes of the evonodes listed so far. + fn mainnet_list_diff( + file_name: &str, + core_23_addresses: bool, + evonodes: &mut BTreeSet, + ) -> MasternodeListDiff { + let json = std::fs::read_to_string( + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests/supporting_files/mainnet_protx_list_diffs") + .join(file_name), + ) + .expect("expected to read the masternode list diff"); + let mut list_diff: Value = serde_json::from_str(&json).expect("expected JSON"); + for masternode in list_diff["addedMNs"] + .as_array_mut() + .expect("expected added masternodes") + { + let is_evonode = masternode["type"] == "Evo"; + if is_evonode { + let pro_tx_hash = masternode["proTxHash"].as_str().expect("a ProTx hash"); + evonodes.insert(pro_tx_hash.to_string()); + } + if core_23_addresses { + let addresses = core_23_state_addresses(&masternode["state"], is_evonode); + masternode["state"]["addresses"] = addresses; + } + } + if core_23_addresses { + for update in list_diff["updatedMNs"] + .as_array_mut() + .expect("expected updated masternodes") + { + for (pro_tx_hash, state_diff) in update.as_object_mut().expect("a diff") { + let is_evonode = evonodes.contains(pro_tx_hash); + if let Some(addresses) = core_23_diff_addresses(state_diff, is_evonode) { + state_diff["addresses"] = addresses; + } + } + } + } + serde_json::from_value(list_diff).expect("expected a masternode list diff") + } + + /// A listed `service`, `None` for a masternode without an address, which + /// Core lists as the unspecified address with port 0. + fn listed_service(service: &Value) -> Option { + let service: SocketAddr = service + .as_str() + .expect("a service") + .parse() + .expect("an ip:port service"); + (!(service.ip().is_unspecified() && service.port() == 0)).then_some(service) + } + + /// `port` on the IP of `service`, as Core prints a network address. + fn on_service_ip(service: SocketAddr, port: u16) -> String { + SocketAddr::new(service.ip(), port).to_string() + } + + fn listed_port(port: &Value) -> u16 { + port.as_u64() + .and_then(|port| u16::try_from(port).ok()) + .expect("a port") + } + + /// The `addresses` Core 23 lists for a masternode that predates extended + /// addresses (`GetNetInfoWithLegacyFields`): its core entry is `service`, + /// and an evonode's platform entries pair the IP of `service` with the + /// legacy ports. A masternode without an address lists no entry. + fn core_23_state_addresses(state: &Value, is_evonode: bool) -> Value { + let Some(service) = listed_service(&state["service"]) else { + return json!({}); + }; + let mut addresses = json!({ "core_p2p": [service.to_string()] }); + if is_evonode { + let http_port = listed_port(&state["platformHTTPPort"]); + let p2p_port = listed_port(&state["platformP2PPort"]); + addresses["platform_https"] = json!([on_service_ip(service, http_port)]); + addresses["platform_p2p"] = json!([on_service_ip(service, p2p_port)]); + } + addresses + } + + /// The `addresses` Core 23 lists in the diff of a masternode that + /// predates extended addresses (`CDeterministicMNStateDiff::ToJson`): with + /// a changed `service`, its core entry; for an evonode, each changed + /// platform port, on the IP of the changed `service`, else on the + /// placeholder host 255.255.255.255. `None` when that lists nothing. + fn core_23_diff_addresses(state_diff: &Value, is_evonode: bool) -> Option { + let service: Option = state_diff.get("service").map(|service| { + service + .as_str() + .expect("a service") + .parse() + .expect("an ip:port service") + }); + let mut addresses = serde_json::Map::new(); + if let Some(service) = state_diff.get("service").and_then(listed_service) { + addresses.insert("core_p2p".to_string(), json!([service.to_string()])); + } + if is_evonode { + for (port_field, purpose) in [ + ("platformP2PPort", "platform_p2p"), + ("platformHTTPPort", "platform_https"), + ] { + if let Some(port) = state_diff.get(port_field).map(listed_port) { + let entry = match service { + Some(service) => on_service_ip(service, port), + None => format!("255.255.255.255:{port}"), + }; + addresses.insert(purpose.to_string(), json!([entry])); + } + } + } + (!addresses.is_empty()).then_some(Value::Object(addresses)) + } + + /// The validator every binary before nested addresses builds for a listed + /// evonode: its ports are the legacy port fields as listed, and it is a + /// validator only with both of them and a platform node id. + fn validator_from_legacy_ports(evonode: &MasternodeListItem) -> Option { + let state = &evonode.state; + #[allow(deprecated)] + let (p2p_port, http_port) = ( + state.legacy_platform_p2p_port?, + state.legacy_platform_http_port?, + ); + Some(ValidatorV0 { + pro_tx_hash: evonode.pro_tx_hash, + public_key: None, + node_ip: state.service.ip().to_string(), + node_id: PubkeyHash::from_byte_array(state.platform_node_id?), + core_port: state.service.port(), + platform_http_port: http_port as u16, + platform_p2p_port: p2p_port as u16, + is_banned: state.pose_ban_height.is_some(), + }) + } + + /// How every binary before nested addresses refreshes a validator-set + /// member from its evonode's diff: on a ban, `service` or legacy P2P port + /// change, it takes the ban, the IP and the legacy ports the diff lists. + fn refresh_from_legacy_ports(member: &mut ValidatorV0, state_diff: &DMNStateDiff) { + #[allow(deprecated)] + let (p2p_port, http_port) = ( + state_diff.legacy_platform_p2p_port, + state_diff.legacy_platform_http_port, + ); + if state_diff.pose_ban_height.is_none() + && state_diff.service.is_none() + && p2p_port.is_none() + { + return; + } + if let Some(pose_ban_height) = state_diff.pose_ban_height { + member.is_banned = pose_ban_height.is_some(); + } + if let Some(service) = state_diff.service { + member.node_ip = service.ip().to_string(); + } + if let Some(p2p_port) = p2p_port { + member.platform_p2p_port = p2p_port as u16; + } + if let Some(http_port) = http_port { + member.platform_http_port = http_port as u16; + } + } + + /// Asserts that `state` lists exactly the `listed` evonodes and gives each + /// the validator binaries before nested addresses build for it. + fn assert_validators_from_legacy_ports( + state: &PlatformState, + listed: &BTreeMap, + context: &str, + ) { + assert!( + state.hpmn_masternode_list().keys().eq(listed.keys()), + "{context}: the same evonodes are listed" + ); + for (pro_tx_hash, evonode) in listed { + assert_eq!( + ValidatorV0::new_validator_if_masternode_in_state(*pro_tx_hash, None, state), + validator_from_legacy_ports(evonode), + "{context}: evonode {pro_tx_hash}" + ); + } + } + + /// Validator-set membership decides quorum rotation, and every binary + /// before nested addresses built it from the legacy port fields alone. + /// For every mainnet evonode, as the fixtures list it and with the + /// `addresses` Core 23 lists beside the legacy fields, the validator a new + /// quorum gets and the member an existing set refreshes from a diff must + /// be exactly what those binaries build. + #[test] + fn should_build_the_validators_earlier_binaries_built_from_mainnet_masternode_lists() { + for platform_version in [ + PlatformVersion::get(13).expect("protocol version 13"), + PlatformVersion::latest(), + ] { + let init_core_height = 2128896; + let next_core_height = 2129440; + let quorum_hash = QuorumHash::from_byte_array([0x55; 32]); + + for core_23_addresses in [false, true] { + let context = if core_23_addresses { + "with Core 23 addresses" + } else { + "as listed" + }; + let mut evonodes = BTreeSet::new(); + let init_list = + mainnet_list_diff("1-2128896.json", core_23_addresses, &mut evonodes); + let list_diff = + mainnet_list_diff("2128896-2129440.json", core_23_addresses, &mut evonodes); + assert!( + list_diff + .updated_mns + .iter() + .any(|(pro_tx_hash, state_diff)| { + evonodes.contains(&pro_tx_hash.to_string()) + && state_diff.service.is_some() + }), + "the diff moves an evonode" + ); + + let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); + let responses = [init_list.clone(), list_diff.clone()]; + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |_base_block, block| { + Ok(responses[usize::from(block != init_core_height)].clone()) + }); + let mut state = PlatformState::default_with_protocol_versions( + platform_version.protocol_version, + platform_version.protocol_version, + &PlatformConfig::default_for_network(Network::Mainnet), + ) + .expect("platform state"); + + // The evonodes as every earlier binary holds them. + let is_evonode = + |masternode: &&MasternodeListItem| masternode.node_type == MasternodeType::Evo; + let mut listed: BTreeMap = init_list + .added_mns + .iter() + .filter(is_evonode) + .map(|evonode| (evonode.pro_tx_hash, evonode.clone())) + .collect(); + + let update = |state: &mut PlatformState, core_height, from_scratch| { + if platform_version.protocol_version == 13 { + platform.update_state_masternode_list_v0(state, core_height, from_scratch) + } else { + platform.update_state_masternode_list_v1(state, core_height, from_scratch) + } + .expect("expected to apply the masternode list") + }; + update(&mut state, init_core_height, true); + assert_validators_from_legacy_ports(&state, &listed, context); + + let members: BTreeMap = listed + .iter() + .filter_map(|(pro_tx_hash, evonode)| { + validator_from_legacy_ports(evonode).map(|member| (*pro_tx_hash, member)) + }) + .collect(); + assert_eq!( + members.len(), + listed.len(), + "{context}: every evonode is a member" + ); + state.insert_validator_set( + quorum_hash, + ValidatorSet::V0(ValidatorSetV0 { + quorum_hash, + quorum_index: None, + core_height: init_core_height, + members: members.clone(), + threshold_public_key: SecretKey::::random( + &mut StdRng::seed_from_u64(1), + ) + .public_key(), + }), + ); + + update(&mut state, next_core_height, false); + + let mut refreshed_members = members.clone(); + for evonode in list_diff.added_mns.iter().filter(is_evonode) { + listed.insert(evonode.pro_tx_hash, evonode.clone()); + } + for (pro_tx_hash, state_diff) in &list_diff.updated_mns { + if let Some(evonode) = listed.get_mut(pro_tx_hash) { + evonode.state.apply_diff(state_diff.clone()); + } + if let Some(member) = refreshed_members.get_mut(pro_tx_hash) { + refresh_from_legacy_ports(member, state_diff); + } + } + for pro_tx_hash in &list_diff.removed_mns { + listed.remove(pro_tx_hash); + refreshed_members.remove(pro_tx_hash); + } + + assert_validators_from_legacy_ports(&state, &listed, context); + assert_ne!( + refreshed_members, members, + "{context}: the diff refreshes members" + ); + assert_eq!( + state.validator_sets()[&quorum_hash].members(), + &refreshed_members, + "{context}: the refreshed members" + ); + } + } + } + /// A platform at `platform_version` whose mock Core returns Dash Core v24 `protx listdiff` /// output: the diff from height 1 to 1250 adds a legacy Evo, a shared masternode, Regular /// masternodes with one and with two payouts (one of them with a Tor primary address), an @@ -371,6 +714,17 @@ mod test { assert_eq!(legacy_evo_validator.platform_p2p_port, 36656); assert_eq!(legacy_evo_validator.platform_http_port, 1443); + // An Evo on an IPv6 primary address is advertised to Tenderdash with + // its host in brackets, as a URL authority requires. + let ipv6_evo_validator = + validator("aecd2830b843e6a84283ba290492a213e355cea7c5026e6118a21e1bfbc36783") + .expect("expected the IPv6 Evo to be a validator"); + assert_eq!(ipv6_evo_validator.node_ip, "2001:db8::4"); + assert_eq!( + node_addresses([ipv6_evo_validator]), + ["tcp://4bcc85253e395ec272998a0722ac3ee1dd3965f7@[2001:db8::4]:26656"] + ); + // Every parsed masternode survives a store and reload, except for the payout list and // nested addresses, which are not stored. for masternode in block_platform_state.full_masternode_list().values() { @@ -523,4 +877,253 @@ mod test { ); } } + + /// The quorum of the validator set `state_after_core_v24_lists` adds. + const VALIDATOR_QUORUM_HASH: [u8; 32] = [0x55; 32]; + + /// The node addresses Drive hands Tenderdash for `validators`, as the + /// members of one validator set. + fn node_addresses(validators: impl IntoIterator) -> Vec { + let quorum_hash = QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH); + ValidatorSet::V0(ValidatorSetV0 { + quorum_hash, + quorum_index: None, + core_height: 1, + members: validators + .into_iter() + .map(|validator| (validator.pro_tx_hash, validator)) + .collect(), + threshold_public_key: SecretKey::::random(&mut StdRng::seed_from_u64( + 1, + )) + .public_key(), + }) + .to_update() + .validator_updates + .into_iter() + .map(|validator_update| validator_update.node_address) + .collect() + } + + /// Runs one masternode list update per `(core height, fixture)`, in order, + /// as Drive runs one per block, with Core reporting the fixture's + /// `protx listdiff` JSON from `core_v24_protx_list_diffs` for that height. + /// Before the last update, one validator set lists every evonode that is a + /// validator then. Returns the state after the last update. + fn state_after_core_v24_lists(fixtures: &[(u32, &str)]) -> PlatformState { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new() + .with_config(PlatformConfig::default()) + .build_with_mock_rpc() + .set_genesis_state(); + + let lists: BTreeMap = fixtures + .iter() + .map(|(core_height, file_name)| { + let json = std::fs::read_to_string( + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests/supporting_files/core_v24_protx_list_diffs") + .join(file_name), + ) + .expect("expected to read the masternode list diff"); + (*core_height, json) + }) + .collect(); + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |_base_block, block| Ok(serde_json::from_str(&lists[&block])?)); + + let transaction = platform.drive.grove.start_transaction(); + let mut platform_state: Option = None; + let mut block_platform_state = platform.state.load().as_ref().clone(); + for (index, (core_height, _)) in fixtures.iter().enumerate() { + let block = index as u64 + 1; + if block == fixtures.len() as u64 { + let members = block_platform_state + .hpmn_masternode_list() + .keys() + .filter_map(|pro_tx_hash| { + ValidatorV0::new_validator_if_masternode_in_state( + *pro_tx_hash, + None, + &block_platform_state, + ) + .map(|member| (*pro_tx_hash, member)) + }) + .collect(); + let quorum_hash = QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH); + block_platform_state.insert_validator_set( + quorum_hash, + ValidatorSet::V0(ValidatorSetV0 { + quorum_hash, + quorum_index: None, + core_height: *core_height, + members, + threshold_public_key: SecretKey::::random( + &mut StdRng::seed_from_u64(1), + ) + .public_key(), + }), + ); + } + platform + .update_masternode_list( + platform_state.as_ref(), + &mut block_platform_state, + *core_height, + index == 0, + &BlockInfo { + height: block, + core_height: *core_height, + time_ms: block, + ..Default::default() + }, + &transaction, + platform_version, + ) + .expect("expected to process the Core v24 masternode list"); + platform_state = Some(block_platform_state.clone()); + } + block_platform_state + } + + /// The validator of `pro_tx_hash` in the validator set + /// `state_after_core_v24_lists` adds, and the one a new quorum gets. + fn existing_and_new_validator( + state: &PlatformState, + pro_tx_hash: &str, + ) -> (Option, Option) { + let pro_tx_hash = ProTxHash::from_str(pro_tx_hash).expect("expected a pro tx hash"); + let validator_set = + &state.validator_sets()[&QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH)]; + ( + validator_set.members().get(&pro_tx_hash).cloned(), + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, state), + ) + } + + /// An ExtAddr evonode keeps its platform ports in its network info, so a + /// ProUpServTx that only moves them reaches Drive as a diff with `service` + /// and the whole `addresses`, and no legacy port field. Tenderdash must be + /// told the new ports, by the existing validator set and by one built + /// later, or it keeps dialling the old ones. + #[test] + fn should_move_the_validator_of_an_ext_addr_evonode_on_a_core_v24_port_only_diff() { + let state = state_after_core_v24_lists(&[ + (1250, "1-1250.json"), + (1260, "1250-1260.json"), + (1270, "1260-1270.json"), + ]); + + let expected = ValidatorV0 { + pro_tx_hash: ProTxHash::from_str( + "ca3d32c4f2ef62eaf736bf41bb3235a832ec1eb6d8dfaccd4d3555e70f6757b0", + ) + .expect("expected a pro tx hash"), + public_key: None, + node_ip: "192.0.2.40".to_string(), + node_id: PubkeyHash::from_byte_array( + hex::decode("9e391c2c041a122a779bafe09d6c47ea600dfcbe") + .expect("expected hex") + .try_into() + .expect("expected 20 bytes"), + ), + core_port: 9999, + platform_http_port: 8443, + platform_p2p_port: 36657, + is_banned: false, + }; + assert_eq!( + existing_and_new_validator( + &state, + "ca3d32c4f2ef62eaf736bf41bb3235a832ec1eb6d8dfaccd4d3555e70f6757b0" + ), + (Some(expected.clone()), Some(expected)) + ); + } + + /// Core lists an evonode whose primary core address is a Tor address with + /// that address as `service`, which reads as `[::]:0`. It becomes a + /// validator on the unspecified IP with the ports of its platform entries: + /// unreachable, but its list does not fail the block. + #[test] + fn should_make_an_evonode_with_a_tor_primary_address_a_validator_on_the_unspecified_ip() { + let state = state_after_core_v24_lists(&[ + (1250, "1-1250.json"), + (1260, "1250-1260.json"), + (1270, "1260-1270.json"), + ]); + + let (_, new_quorum_validator) = existing_and_new_validator( + &state, + "99e719c608d603658f296acd00f271345a29e391e2d717d3615062f9a961920c", + ); + assert_eq!( + new_quorum_validator, + Some(ValidatorV0 { + pro_tx_hash: ProTxHash::from_str( + "99e719c608d603658f296acd00f271345a29e391e2d717d3615062f9a961920c", + ) + .expect("expected a pro tx hash"), + public_key: None, + node_ip: "::".to_string(), + node_id: PubkeyHash::from_byte_array( + hex::decode("9cea9116b333eba7631804e1be7efd62c56d5b58") + .expect("expected hex") + .try_into() + .expect("expected 20 bytes"), + ), + core_port: 0, + platform_http_port: 443, + platform_p2p_port: 26656, + is_banned: false, + }) + ); + assert_eq!( + node_addresses(new_quorum_validator), + ["tcp://9cea9116b333eba7631804e1be7efd62c56d5b58@[::]:26656"] + ); + } + + /// Before V24, a ProUpServTx that only moves a legacy evonode's P2P port + /// reaches Drive as the legacy port field and a platform entry on the + /// placeholder host 255.255.255.255, since the diff carries no address. + /// The validator takes the new port and keeps the evonode's IP. + #[test] + fn should_move_the_validator_of_a_legacy_evonode_on_a_core_v24_port_diff() { + let state = state_after_core_v24_lists(&[ + (1000, "before_v24/1-1000.json"), + (1010, "before_v24/1000-1010.json"), + ]); + + let expected = ValidatorV0 { + pro_tx_hash: ProTxHash::from_str( + "86e4a4274da5610322340e2f34adf8f6f2899f78b2ce1c31281b6d1754a88d76", + ) + .expect("expected a pro tx hash"), + public_key: None, + node_ip: "192.0.2.60".to_string(), + node_id: PubkeyHash::from_byte_array( + hex::decode("416e5b04d3047def070bea5175431ca7732b4b7b") + .expect("expected hex") + .try_into() + .expect("expected 20 bytes"), + ), + core_port: 9999, + platform_http_port: 443, + platform_p2p_port: 36657, + is_banned: false, + }; + assert_eq!( + existing_and_new_validator( + &state, + "86e4a4274da5610322340e2f34adf8f6f2899f78b2ce1c31281b6d1754a88d76" + ), + (Some(expected.clone()), Some(expected)) + ); + } } + +#[cfg(test)] +mod versioning_tests; diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/mod.rs index 383eddf5abd..d0ad9c9e79e 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/mod.rs @@ -1,3 +1,4 @@ mod v0; +mod v1; -//internal method, doesn't need to be be versioned off of platform version +// Private helpers are selected by the update_masternode_list generation. diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v0/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v0/mod.rs index 1138c3aad35..e5518c423d3 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v0/mod.rs @@ -286,7 +286,7 @@ mod tests { PlatformState, ProTxHash, ) { - let platform_version = PlatformVersion::latest(); + let platform_version = PlatformVersion::get(13).expect("protocol version 13"); let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); let pro_tx_hash = ProTxHash::from_byte_array([0x77u8; 32]); @@ -381,7 +381,7 @@ mod tests { #[test] fn should_only_upsert_changed_entries_in_a_mixed_masternode_diff() { - let platform_version = PlatformVersion::latest(); + let platform_version = PlatformVersion::get(13).expect("protocol version 13"); let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); let mut state = PlatformState::default_with_protocol_versions( platform_version.protocol_version, diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v1/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v1/mod.rs new file mode 100644 index 00000000000..996608f515f --- /dev/null +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/update_state_masternode_list/v1/mod.rs @@ -0,0 +1,1325 @@ +use crate::error::Error; +use crate::execution::types::update_state_masternode_list_outcome; +use crate::platform_types::masternode::v0::MasternodeStateV0; +use crate::platform_types::platform::Platform; +use crate::platform_types::platform_state::PlatformState; +use crate::platform_types::platform_state::PlatformStateV0Methods; + +use crate::platform_types::validator_set::v0::ValidatorSetV0Getters; +use crate::rpc::core::CoreRPCLike; +use dpp::dashcore::{ProTxHash, QuorumHash}; +use dpp::dashcore_rpc::dashcore_rpc_json::{ + DMNState, DMNStateDiff, MasternodeListDiff, MasternodeListItem, +}; +use std::collections::{BTreeMap, BTreeSet}; + +impl Platform +where + C: CoreRPCLike, +{ + /// The quorum hashes of the validator sets the masternode is a member of. + fn validator_sets_with_member_v1( + state: &PlatformState, + pro_tx_hash: &ProTxHash, + ) -> Vec { + state + .validator_sets() + .iter() + .filter(|(_, validator_set)| validator_set.members().contains_key(pro_tx_hash)) + .map(|(quorum_hash, _)| *quorum_hash) + .collect() + } + + /// Remove a masternode from every validator set it is a member of. + /// + /// Only the validator sets that list the masternode are touched, so only + /// their entries are rewritten by the per-entry store. + fn remove_masternode_in_validator_sets_v1(pro_tx_hash: &ProTxHash, state: &mut PlatformState) { + for quorum_hash in Self::validator_sets_with_member_v1(state, pro_tx_hash) { + if let Some(validator_set) = state.validator_set_mut(&quorum_hash) { + validator_set.members_mut().remove(pro_tx_hash); + } + } + } + + /// Updates a masternode in the validator sets. + /// + /// This function updates the properties of the masternode that matches the given `pro_tx_hash`. + /// The ban status and service address are updated based on the provided `dmn_state_diff` + /// information, the platform P2P and HTTP ports from `new_platform_ports`. + /// + /// # Arguments + /// + /// * `pro_tx_hash` - The `ProTxHash` of the masternode to be updated + /// * `dmn_state_diff` - The `DMNStateDiff` containing the updated masternode information + /// * `new_platform_ports` - The platform ports that resolve to a new value in the updated + /// masternode state + /// * `state` - The platform state whose validator sets are updated; only the + /// sets that list the masternode are touched + fn update_masternode_in_validator_sets_v1( + pro_tx_hash: &ProTxHash, + dmn_state_diff: &DMNStateDiff, + new_platform_ports: PlatformPorts, + state: &mut PlatformState, + ) { + for quorum_hash in Self::validator_sets_with_member_v1(state, pro_tx_hash) { + let Some(validator_set) = state.validator_set_mut(&quorum_hash) else { + continue; + }; + let Some(validator) = validator_set.members_mut().get_mut(pro_tx_hash) else { + continue; + }; + if let Some(maybe_ban_height) = dmn_state_diff.pose_ban_height { + // the ban_height was changed + validator.is_banned = maybe_ban_height.is_some(); + } + if let Some(address) = dmn_state_diff.service { + validator.node_ip = address.ip().to_string(); + } + + if let Some(p2p_port) = new_platform_ports.p2p { + validator.platform_p2p_port = p2p_port; + } + + if let Some(http_port) = new_platform_ports.http { + validator.platform_http_port = http_port; + } + } + } + + /// Whether applying `updated_mns` would change any item of `masternode_list`. + /// + /// Core reports a masternode as updated whenever any field of its state + /// moved, including the payment and penalty fields — last paid height, + /// consecutive payments, PoSe penalty — that change on nearly every Core + /// block and that the stored item does not keep. Applying each diff to a + /// copy tells the two apart. + fn any_stored_masternode_changes_v1( + masternode_list: &BTreeMap, + updated_mns: &[(ProTxHash, DMNStateDiff)], + ) -> bool { + updated_mns.iter().any(|(pro_tx_hash, state_diff)| { + masternode_list.get(pro_tx_hash).is_some_and(|item| { + apply_diff_in_stored_form(&item.state, state_diff) + != legacy_stored_form(item.state.clone()) + }) + }) + } + + pub(crate) fn update_state_masternode_list_v1( + &self, + state: &mut PlatformState, + core_block_height: u32, + start_from_scratch: bool, + ) -> Result + { + let previous_core_height = if start_from_scratch { + // baseBlock must be a chain height and not 0 + None + } else { + let state_core_height = state.last_committed_core_height(); + if core_block_height == state_core_height { + return Ok(update_state_masternode_list_outcome::v0::UpdateStateMasternodeListOutcome::default()); + // no need to do anything + } + Some(state_core_height) + }; + + let masternode_diff = self + .core_rpc + .get_protx_diff_with_masternodes(previous_core_height, core_block_height)?; + + let MasternodeListDiff { + added_mns, + removed_mns, + updated_mns, + .. + } = &masternode_diff; + + // Core advances a block without any stored masternode field changing far + // more often than not: on mainnet almost every block's diff is only the + // payment fields of the masternode paid in it. Returning before the + // first mutable borrow keeps the platform state clean, which is what + // lets the block skip rewriting the full saved state (over a megabyte + // on mainnet) to disk. + if !start_from_scratch + && added_mns.is_empty() + && removed_mns.is_empty() + && !Self::any_stored_masternode_changes_v1(state.full_masternode_list(), updated_mns) + { + return Ok( + update_state_masternode_list_outcome::v0::UpdateStateMasternodeListOutcome { + masternode_list_diff: masternode_diff, + removed_masternodes: BTreeMap::new(), + }, + ); + } + + // Every change below goes through an accessor that records which + // masternode or validator set it touched, so the store writes only + // those entries. + if start_from_scratch { + state.clear_masternode_lists(); + } + + for masternode in added_mns { + let mut masternode = masternode.clone(); + masternode.state = in_stored_form(masternode.state); + state.insert_masternode(masternode); + } + + for (pro_tx_hash, state_diff) in updated_mns { + let Some(mut masternode) = state.full_masternode_list().get(pro_tx_hash).cloned() + else { + continue; + }; + // Old in-memory addresses were not persisted before this generation. Start + // from the stored state so a running node and a restarted node agree. + let previous_state = legacy_stored_form(masternode.state.clone()); + let updated_state = apply_diff_in_stored_form(&previous_state, state_diff); + let is_hpmn = state.hpmn_masternode_list().contains_key(pro_tx_hash); + let platform_ports_before = is_hpmn.then(|| PlatformPorts::of(&previous_state)); + let platform_ports = is_hpmn.then(|| PlatformPorts::of(&updated_state)); + if updated_state != previous_state { + masternode.state = updated_state; + state.insert_masternode(masternode); + } + // Only evonodes are validators. + let (Some(platform_ports_before), Some(platform_ports)) = + (platform_ports_before, platform_ports) + else { + continue; + }; + // The ports are read from the updated state, not from the diff: an + // ExtAddr evonode's port move reaches us only in `addresses`, and a + // legacy evonode's diff lists there just the entries that changed. + let new_platform_ports = changed_platform_ports(platform_ports_before, platform_ports); + // the ban status, the IP and the platform P2P port are the only fields that are useful for + // validators. If they change we need to update validator sets + if state_diff.pose_ban_height.is_some() + || state_diff.service.is_some() + || new_platform_ports.p2p.is_some() + { + // we updated the ban status the IP or the platform port, we need to update the validator in the validator list + Self::update_masternode_in_validator_sets_v1( + pro_tx_hash, + state_diff, + new_platform_ports, + state, + ); + } + } + + for pro_tx_hash in removed_mns { + Self::remove_masternode_in_validator_sets_v1(pro_tx_hash, state); + } + + let deleted_masternodes = removed_mns.iter().copied().collect::>(); + + let mut removed_masternodes = BTreeMap::new(); + + for key in deleted_masternodes { + if let Some(value) = state.remove_masternode(&key) { + removed_masternodes.insert(key, value); + } + } + + Ok( + update_state_masternode_list_outcome::v0::UpdateStateMasternodeListOutcome { + masternode_list_diff: masternode_diff, + removed_masternodes, + }, + ) + } +} + +/// The ports of `after` that resolve to a value other than in `before`. +/// +/// A port that stops resolving is not reported, so the validator keeps its +/// last known port. +fn changed_platform_ports(before: PlatformPorts, after: PlatformPorts) -> PlatformPorts { + PlatformPorts { + p2p: after.p2p.filter(|_| after.p2p != before.p2p), + http: after.http.filter(|_| after.http != before.http), + } +} + +/// The old persisted state, without transient address or payout lists. +fn legacy_stored_form(state: DMNState) -> DMNState { + MasternodeStateV0::from(state).into() +} + +/// Resolves nested ports into the unchanged persisted fields. The global +/// converters stay literal so earlier protocol generations keep their behavior. +fn in_stored_form(mut state: DMNState) -> DMNState { + let p2p = state.platform_p2p_address().map(|(_, port)| port); + let http = state.platform_http_address().map(|(_, port)| port); + #[allow(deprecated)] + { + state.legacy_platform_p2p_port = p2p.or(state.legacy_platform_p2p_port); + state.legacy_platform_http_port = http.or(state.legacy_platform_http_port); + } + legacy_stored_form(state) +} + +fn apply_diff_in_stored_form(state: &DMNState, diff: &DMNStateDiff) -> DMNState { + let mut updated = legacy_stored_form(state.clone()); + updated.apply_diff(diff.clone()); + in_stored_form(updated) +} + +/// Platform ports resolved for this generation's validator updates. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct PlatformPorts { + p2p: Option, + http: Option, +} + +impl PlatformPorts { + fn of(state: &DMNState) -> Self { + Self { + p2p: state + .platform_p2p_address() + .and_then(|(_, port)| u16::try_from(port).ok()), + http: state + .platform_http_address() + .and_then(|(_, port)| u16::try_from(port).ok()), + } + } +} + +#[cfg(test)] +mod tests { + use super::{in_stored_form, PlatformPorts}; + use crate::config::{PlatformConfig, PlatformTestConfig}; + use crate::platform_types::masternode::v0::MasternodeV0; + use crate::platform_types::platform::Platform; + use crate::platform_types::platform_state::PlatformState; + use crate::platform_types::platform_state::PlatformStateV0Methods; + use crate::platform_types::validator::v0::NewValidatorIfMasternodeInState; + use crate::platform_types::validator_set::v0::ValidatorSetV0Getters; + use crate::platform_types::validator_set::{ValidatorSet, ValidatorSetExt}; + use crate::rpc::core::MockCoreRPCLike; + use crate::test::helpers::setup::{TempPlatform, TestPlatformBuilder}; + use dpp::bls_signatures::{Bls12381G2Impl, SecretKey}; + use dpp::core_types::validator::v0::ValidatorV0; + use dpp::core_types::validator_set::v0::ValidatorSetV0; + use dpp::dashcore::hashes::Hash; + use dpp::dashcore::{Network, ProTxHash, PubkeyHash, QuorumHash, ScriptBuf, Txid}; + use dpp::dashcore_rpc::dashcore_rpc_json::{ + DMNPayout, DMNState, DMNStateDiff, MasternodeAddresses, MasternodeListDiff, + MasternodeListItem, MasternodeType, + }; + use dpp::version::PlatformVersion; + use rand::rngs::StdRng; + use rand::SeedableRng; + use std::collections::{BTreeMap, BTreeSet}; + + fn masternode(pro_tx_hash: ProTxHash) -> MasternodeListItem { + MasternodeListItem { + node_type: MasternodeType::Regular, + pro_tx_hash, + collateral_hash: Txid::from_byte_array([0u8; 32]), + collateral_index: 0, + collateral_address: Some([0u8; 20]), + operator_reward: 0.0, + state: DMNState { + service: "1.2.3.4:1234".parse().expect("socket address"), + registered_height: 0, + pose_revived_height: None, + pose_ban_height: None, + revocation_reason: 0, + owner_address: Some([0u8; 20]), + voting_address: [0u8; 20], + payout_address: Some([0u8; 20]), + payouts: None, + pub_key_operator: vec![0u8; 48], + operator_payout_address: None, + platform_node_id: None, + #[allow(deprecated)] + legacy_platform_p2p_port: None, + #[allow(deprecated)] + legacy_platform_http_port: None, + addresses: None, + }, + } + } + + /// A diff with no field set: what Core reports for a masternode is added + /// on top of this. + fn empty_state_diff() -> DMNStateDiff { + DMNStateDiff { + service: None, + registered_height: None, + last_paid_height: None, + consecutive_payments: None, + pose_penalty: None, + pose_revived_height: None, + pose_ban_height: None, + revocation_reason: None, + owner_address: None, + voting_address: None, + payout_address: None, + payouts: None, + pub_key_operator: None, + operator_payout_address: None, + platform_node_id: None, + #[allow(deprecated)] + legacy_platform_p2p_port: None, + #[allow(deprecated)] + legacy_platform_http_port: None, + addresses: None, + } + } + + /// A clean state holding one masternode, and a platform whose Core reports + /// `state_diff` for it on the next block. + fn state_with_one_masternode_and_diff( + state_diff: DMNStateDiff, + ) -> (TempPlatform, PlatformState, ProTxHash) { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); + + let pro_tx_hash = ProTxHash::from_byte_array([0x77u8; 32]); + let mut state = PlatformState::default_with_protocol_versions( + platform_version.protocol_version, + platform_version.protocol_version, + &PlatformConfig::default_for_network(Network::Testnet), + ) + .expect("platform state"); + state.insert_masternode(masternode(pro_tx_hash)); + state.mark_saved(); + + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |base_block, block| { + Ok(MasternodeListDiff { + base_height: base_block.unwrap_or_default(), + block_height: block, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![(pro_tx_hash, state_diff.clone())], + }) + }); + + (platform, state, pro_tx_hash) + } + + /// Core reports the masternode paid in a block as updated, but the stored + /// item keeps none of the payment fields, so nothing changes and the state + /// must stay clean: this is what almost every mainnet block's diff is. + #[test] + fn payment_only_update_leaves_the_state_clean() { + let (platform, mut state, pro_tx_hash) = state_with_one_masternode_and_diff(DMNStateDiff { + last_paid_height: Some(2_129_183), + consecutive_payments: Some(1), + pose_penalty: Some(0), + ..empty_state_diff() + }); + let before = state.full_masternode_list().clone(); + + platform + .update_state_masternode_list_v1(&mut state, 1, false) + .expect("update must succeed"); + + assert!( + !state.heavy_fields_dirty, + "a diff that changes no stored field must not dirty the state" + ); + assert!( + state.masternode_changes.is_empty(), + "and no entry needs rewriting" + ); + assert_eq!(state.full_masternode_list(), &before); + assert!(state.full_masternode_list().contains_key(&pro_tx_hash)); + } + + /// Transient nested addresses from a previous generation do not constitute + /// a stored change when Core reports only payment metadata. + #[test] + fn should_keep_a_payment_only_diff_clean_with_old_transient_addresses() { + let (platform, mut state, pro_tx_hash) = state_with_one_masternode_and_diff(DMNStateDiff { + last_paid_height: Some(42), + ..empty_state_diff() + }); + let mut item = evonode(); + item.state.addresses = Some(moved_platform_ports()); + state.insert_masternode(item); + state.mark_saved(); + let before = state.full_masternode_list()[&pro_tx_hash].clone(); + + platform + .update_state_masternode_list_v1(&mut state, 1, false) + .expect("update"); + + assert!(!state.heavy_fields_dirty); + assert!(state.masternode_changes.is_empty()); + assert_eq!(state.full_masternode_list()[&pro_tx_hash], before); + } + + /// A diff that does change a stored field is applied and dirties the state, + /// so the check above does not swallow real changes. + #[test] + fn stored_field_update_is_applied_and_dirties_the_state() { + let new_service = "5.6.7.8:5678".parse().expect("socket address"); + let (platform, mut state, pro_tx_hash) = state_with_one_masternode_and_diff(DMNStateDiff { + last_paid_height: Some(2_129_183), + service: Some(new_service), + ..empty_state_diff() + }); + + platform + .update_state_masternode_list_v1(&mut state, 1, false) + .expect("update must succeed"); + + assert!(state.heavy_fields_dirty); + assert_eq!( + state.masternode_changes.upserted, + BTreeSet::from([pro_tx_hash]), + "exactly the changed masternode's entry is rewritten" + ); + assert!(!state.masternode_changes.rewrite_all); + assert_eq!( + state + .full_masternode_list() + .get(&pro_tx_hash) + .expect("masternode stays listed") + .state + .service, + new_service + ); + } + + #[test] + fn should_only_upsert_changed_entries_in_a_mixed_masternode_diff() { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); + let mut state = PlatformState::default_with_protocol_versions( + platform_version.protocol_version, + platform_version.protocol_version, + &PlatformConfig::default_for_network(Network::Testnet), + ) + .expect("platform state"); + let changed_hash = ProTxHash::from_byte_array([0x11; 32]); + let payment_only_hash = ProTxHash::from_byte_array([0x22; 32]); + for pro_tx_hash in [changed_hash, payment_only_hash] { + let mut item = evonode(); + item.pro_tx_hash = pro_tx_hash; + // Transient addresses can survive in memory from the preceding + // protocol generation, but do not make payment metadata a write. + item.state.addresses = Some(moved_platform_ports()); + state.insert_masternode(item); + } + state.mark_saved(); + let unchanged = state.full_masternode_list()[&payment_only_hash].clone(); + let new_service = "5.6.7.8:5678".parse().expect("socket address"); + + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |base_block, block| { + Ok(MasternodeListDiff { + base_height: base_block.unwrap_or_default(), + block_height: block, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![ + ( + changed_hash, + DMNStateDiff { + service: Some(new_service), + ..empty_state_diff() + }, + ), + ( + payment_only_hash, + DMNStateDiff { + last_paid_height: Some(2_129_183), + consecutive_payments: Some(1), + pose_penalty: Some(0), + ..empty_state_diff() + }, + ), + ], + }) + }); + + platform + .update_state_masternode_list_v1(&mut state, 1, false) + .expect("update must succeed"); + + assert_eq!(state.full_masternode_list()[&payment_only_hash], unchanged); + assert_eq!(state.hpmn_masternode_list()[&payment_only_hash], unchanged); + assert_eq!( + state.full_masternode_list()[&changed_hash].state.service, + new_service + ); + assert_eq!( + state.hpmn_masternode_list()[&changed_hash].state.service, + new_service + ); + assert_eq!( + state.masternode_changes.upserted, + BTreeSet::from([changed_hash]), + "payment-only updates must not cause writes alongside a real change" + ); + assert!(state.masternode_changes.removed.is_empty()); + assert!(!state.masternode_changes.rewrite_all); + } + + /// The IP every test evonode is registered with. + const SERVICE_IP: &str = "1.2.3.4"; + const EVONODE_PRO_TX_HASH: [u8; 32] = [0x77u8; 32]; + const VALIDATOR_QUORUM_HASH: [u8; 32] = [0x55u8; 32]; + + fn evonode_pro_tx_hash() -> ProTxHash { + ProTxHash::from_byte_array(EVONODE_PRO_TX_HASH) + } + + /// An evonode with platform ports 36656 (P2P) and 443 (HTTPS), as Core + /// lists it with `-deprecatedrpc=service`: the legacy port fields carry + /// the live ports and `addresses` repeats them. + fn evonode() -> MasternodeListItem { + let mut item = masternode(evonode_pro_tx_hash()); + item.node_type = MasternodeType::Evo; + item.state.platform_node_id = Some([7u8; 20]); + #[allow(deprecated)] + { + item.state.legacy_platform_p2p_port = Some(36656); + item.state.legacy_platform_http_port = Some(443); + } + item.state.addresses = Some(MasternodeAddresses { + core_p2p: vec!["1.2.3.4:1234".to_string()], + platform_p2p: vec!["1.2.3.4:36656".to_string()], + platform_https: vec!["1.2.3.4:443".to_string()], + }); + item + } + + /// The same evonode in a state whose legacy ports are absent: the ports + /// are only in `addresses`. + fn evonode_without_legacy_ports() -> MasternodeListItem { + let mut item = evonode(); + #[allow(deprecated)] + { + item.state.legacy_platform_p2p_port = None; + item.state.legacy_platform_http_port = None; + } + item + } + + /// `item` as a node that restarted holds it: loaded back from storage. + fn reloaded(item: MasternodeListItem) -> MasternodeListItem { + MasternodeV0::from(item).into() + } + + /// Runs one masternode list update per diff, in order, for a state + /// holding `evonode` as a member of one validator set, with Core reporting + /// the diffs for it, and returns the state afterwards. + fn state_after_diffs( + mut evonode: MasternodeListItem, + diffs: Vec, + ) -> PlatformState { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new().build_with_mock_rpc(); + + let pro_tx_hash = evonode.pro_tx_hash; + let quorum_hash = QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH); + let mut state = PlatformState::default_with_protocol_versions( + platform_version.protocol_version, + platform_version.protocol_version, + &PlatformConfig::default_for_network(Network::Testnet), + ) + .expect("platform state"); + evonode.state = in_stored_form(evonode.state); + state.insert_masternode(evonode); + let validator = ValidatorV0 { + pro_tx_hash, + public_key: None, + node_ip: SERVICE_IP.to_string(), + node_id: PubkeyHash::from_byte_array([7u8; 20]), + core_port: 1234, + platform_http_port: 443, + platform_p2p_port: 36656, + is_banned: false, + }; + let mut rng = StdRng::seed_from_u64(1); + state.insert_validator_set( + quorum_hash, + ValidatorSet::V0(ValidatorSetV0 { + quorum_hash, + quorum_index: None, + core_height: 1, + members: BTreeMap::from([(pro_tx_hash, validator)]), + threshold_public_key: SecretKey::::random(&mut rng).public_key(), + }), + ); + state.mark_saved(); + + let block_count = diffs.len() as u32; + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |base_block, block| { + Ok(MasternodeListDiff { + base_height: base_block.unwrap_or_default(), + block_height: block, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![(pro_tx_hash, diffs[block as usize - 1].clone())], + }) + }); + + for block in 1..=block_count { + platform + .update_state_masternode_list_v1(&mut state, block, false) + .expect("update must succeed"); + } + + state + } + + /// The evonode's member of the validator set. + fn validator_in(state: &PlatformState) -> ValidatorV0 { + state.validator_sets()[&QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH)].members() + [&evonode_pro_tx_hash()] + .clone() + } + + /// The validator a quorum Drive learns about later gets for the evonode, + /// once from the state as held in memory and once as a node that + /// restarted loads it back. Validator-set membership decides quorum + /// rotation, so every node must build the same one. + fn validators_for_a_new_quorum(state: &PlatformState) -> [Option; 2] { + let pro_tx_hash = evonode_pro_tx_hash(); + let mut restarted = state.clone(); + restarted.insert_masternode(reloaded(state.full_masternode_list()[&pro_tx_hash].clone())); + [state, &restarted].map(|state| { + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, state) + }) + } + + /// Asserts that the evonode's member of the existing validator set has + /// the given ports, and that a new quorum gets the same member. + fn assert_validator_ports(state: &PlatformState, p2p_port: u16, http_port: u16) { + let validator = validator_in(state); + assert_eq!(validator.node_ip, SERVICE_IP); + assert_eq!(validator.platform_p2p_port, p2p_port); + assert_eq!(validator.platform_http_port, http_port); + for new_quorum_validator in validators_for_a_new_quorum(state) { + assert_eq!(new_quorum_validator.as_ref(), Some(&validator)); + } + } + + /// The network info of the evonode after moving to platform ports 36657 + /// (P2P) and 8443 (HTTPS), as Core prints an ExtAddr one. + fn moved_platform_ports() -> MasternodeAddresses { + MasternodeAddresses { + core_p2p: vec!["1.2.3.4:1234".to_string()], + platform_p2p: vec!["1.2.3.4:36657".to_string()], + platform_https: vec!["1.2.3.4:8443".to_string()], + } + } + + /// A node that restarts reloads its masternode lists from storage, and + /// validator-set membership, which decides quorum rotation, must not + /// depend on whether it did. So after every masternode list update the + /// lists held in memory must be exactly what storage gives back. The + /// updates: an ExtAddr evonode added with its platform ports in + /// `addresses` and a payout list, a port move that only `addresses` + /// carries, then a revoke that zeroes the legacy ports and carries no + /// `addresses`. + #[test] + fn should_hold_after_every_update_the_masternode_lists_a_restarted_node_loads() { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new() + .with_config(PlatformConfig { + testing_configs: PlatformTestConfig { + store_platform_state: true, + ..PlatformTestConfig::default_minimal_verifications() + }, + ..Default::default() + }) + .build_with_mock_rpc() + .set_genesis_state(); + + let mut added = evonode(); + added.collateral_address = Some([0x21; 20]); + added.state.owner_address = Some([0x22; 20]); + added.state.payout_address = None; + added.state.payouts = Some(vec![DMNPayout { + address: [0x23; 20], + script: ScriptBuf::new_p2pkh(&PubkeyHash::from_byte_array([0x23; 20])), + reward: 10000, + }]); + let pro_tx_hash = added.pro_tx_hash; + let port_move = DMNStateDiff { + addresses: Some(Some(moved_platform_ports())), + ..empty_state_diff() + }; + #[allow(deprecated)] + let revoke = DMNStateDiff { + service: Some("[::]:0".parse().expect("socket address")), + pose_ban_height: Some(Some(3)), + revocation_reason: Some(1), + platform_node_id: Some([0u8; 20]), + pub_key_operator: Some(vec![1u8; 48]), + legacy_platform_p2p_port: Some(0), + legacy_platform_http_port: Some(0), + ..empty_state_diff() + }; + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |base_block, block| { + let (added_mns, updated_mns) = match block { + 1 => (vec![added.clone()], vec![]), + 2 => (vec![], vec![(pro_tx_hash, port_move.clone())]), + _ => (vec![], vec![(pro_tx_hash, revoke.clone())]), + }; + Ok(MasternodeListDiff { + base_height: base_block.unwrap_or_default(), + block_height: block, + added_mns, + removed_mns: vec![], + updated_mns, + }) + }); + + let transaction = platform.drive.grove.start_transaction(); + let mut state = platform.state.load().as_ref().clone(); + // The ports and ban each update leaves the evonode with. + let expected = [ + (Some(36656), Some(443), false), + (Some(36657), Some(8443), false), + (Some(0), Some(0), true), + ]; + for (block, (p2p, http, is_banned)) in (1..).zip(expected) { + platform + .update_state_masternode_list_v1(&mut state, block, false) + .expect("update must succeed"); + platform + .store_platform_state(&state, Some(&transaction), platform_version) + .expect("store platform state"); + state.mark_saved(); + let reloaded = Platform::::fetch_platform_state( + &platform.drive, + Some(&transaction), + platform_version, + ) + .expect("fetch platform state") + .expect("a state was stored"); + + assert_eq!( + reloaded.full_masternode_list(), + state.full_masternode_list(), + "the full list after block {block}" + ); + assert_eq!( + reloaded.hpmn_masternode_list(), + state.hpmn_masternode_list(), + "the evonode list after block {block}" + ); + let evonode = &reloaded.hpmn_masternode_list()[&pro_tx_hash].state; + assert_eq!( + ( + PlatformPorts::of(evonode), + evonode.pose_ban_height.is_some() + ), + (PlatformPorts { p2p, http }, is_banned), + "the evonode after block {block}" + ); + } + } + + /// An ExtAddr evonode keeps its platform ports in its network info and its + /// legacy port fields at zero, so a ProUpServTx that only moves its ports + /// reaches Drive as a diff whose only network field is `addresses` + /// (`service` too only with `-deprecatedrpc=service`). Tenderdash must be + /// told the new port, or it keeps dialling the old one. + #[test] + fn should_update_validator_ports_from_an_addresses_only_diff() { + let state = state_after_diffs( + evonode_without_legacy_ports(), + vec![DMNStateDiff { + addresses: Some(Some(moved_platform_ports())), + ..empty_state_diff() + }], + ); + + assert_validator_ports(&state, 36657, 8443); + } + + /// The same port move as Core prints it with `-deprecatedrpc=service`: + /// `service` repeats because the network info changed, while the legacy + /// port fields are absent because they did not change. + #[test] + fn should_update_validator_ports_from_addresses_when_the_diff_also_carries_service() { + let state = state_after_diffs( + evonode(), + vec![DMNStateDiff { + service: Some("1.2.3.4:1234".parse().expect("socket address")), + addresses: Some(Some(moved_platform_ports())), + ..empty_state_diff() + }], + ); + + assert_validator_ports(&state, 36657, 8443); + } + + /// An ExtAddr evonode that moves only its HTTPS port lists its whole + /// network info again, the unchanged P2P entry included. + #[test] + fn should_update_the_validator_https_port_when_only_it_moved() { + let state = state_after_diffs( + evonode(), + vec![DMNStateDiff { + service: Some("1.2.3.4:1234".parse().expect("socket address")), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec!["1.2.3.4:1234".to_string()], + platform_p2p: vec!["1.2.3.4:36656".to_string()], + platform_https: vec!["1.2.3.4:8443".to_string()], + })), + ..empty_state_diff() + }], + ); + + assert_validator_ports(&state, 36656, 8443); + } + + /// HTTPS alone is not an existing-validator refresh trigger. New quorums + /// still use the updated stored HTTPS port. + #[test] + fn should_keep_the_existing_validator_https_port_without_a_refresh_trigger() { + let state = state_after_diffs( + evonode(), + vec![DMNStateDiff { + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec![], + platform_p2p: vec![], + platform_https: vec!["1.2.3.4:8443".to_string()], + })), + ..empty_state_diff() + }], + ); + assert_eq!(validator_in(&state).platform_http_port, 443); + for validator in validators_for_a_new_quorum(&state) { + assert_eq!(validator.expect("new validator").platform_http_port, 8443); + } + } + + /// When a legacy evonode changes only a platform port, the diff does not + /// carry the node's IP, so Core pairs the new port in `addresses` with the + /// placeholder host 255.255.255.255. Only the port may be taken from it. + #[test] + fn should_not_take_the_placeholder_host_from_a_legacy_evonode_port_diff() { + let state = state_after_diffs( + evonode(), + vec![DMNStateDiff { + #[allow(deprecated)] + legacy_platform_p2p_port: Some(36657), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec![], + platform_p2p: vec!["255.255.255.255:36657".to_string()], + platform_https: vec![], + })), + ..empty_state_diff() + }], + ); + + assert_validator_ports(&state, 36657, 443); + } + + /// A legacy evonode's diff lists in `addresses` only the entries that + /// changed, next to the changed legacy port field. A later diff that + /// changes the other port must not undo an earlier one's port. + #[test] + fn should_keep_each_platform_port_from_diffs_that_list_one_entry_each() { + let state = state_after_diffs( + evonode(), + vec![ + DMNStateDiff { + #[allow(deprecated)] + legacy_platform_p2p_port: Some(36657), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec![], + platform_p2p: vec!["255.255.255.255:36657".to_string()], + platform_https: vec![], + })), + ..empty_state_diff() + }, + DMNStateDiff { + #[allow(deprecated)] + legacy_platform_http_port: Some(8443), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec![], + platform_p2p: vec![], + platform_https: vec!["255.255.255.255:8443".to_string()], + })), + ..empty_state_diff() + }, + ], + ); + + assert_eq!(validator_in(&state).platform_p2p_port, 36657); + for new_quorum_validator in validators_for_a_new_quorum(&state) { + let new_quorum_validator = new_quorum_validator.expect("the evonode has ports"); + assert_eq!(new_quorum_validator.platform_p2p_port, 36657); + assert_eq!(new_quorum_validator.platform_http_port, 8443); + } + } + + /// A diff of a legacy evonode's core address carries `addresses` with the + /// core entry only, so the platform ports must not be read as cleared. + #[test] + fn should_keep_validator_ports_when_a_diff_moves_only_the_core_address() { + let state = state_after_diffs( + evonode(), + vec![DMNStateDiff { + service: Some("5.6.7.8:1234".parse().expect("socket address")), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec!["5.6.7.8:1234".to_string()], + platform_p2p: vec![], + platform_https: vec![], + })), + ..empty_state_diff() + }], + ); + + let validator = validator_in(&state); + assert_eq!(validator.node_ip, "5.6.7.8"); + assert_eq!(validator.platform_p2p_port, 36656); + assert_eq!(validator.platform_http_port, 443); + for new_quorum_validator in validators_for_a_new_quorum(&state) { + assert_eq!(new_quorum_validator.as_ref(), Some(&validator)); + } + } + + /// A node that restarted holds the evonode without `addresses`. A diff + /// that lists only the core entry must leave its platform ports as they + /// are, as on a node that kept its state in memory. + #[test] + fn should_keep_validator_ports_after_a_restart_when_a_diff_moves_only_the_core_address() { + let state = state_after_diffs( + reloaded(evonode()), + vec![DMNStateDiff { + service: Some("1.2.3.4:1234".parse().expect("socket address")), + addresses: Some(Some(MasternodeAddresses { + core_p2p: vec!["1.2.3.4:1234".to_string()], + platform_p2p: vec![], + platform_https: vec![], + })), + ..empty_state_diff() + }], + ); + + assert_validator_ports(&state, 36656, 443); + } + + /// After V24 a legacy evonode's revoke, or an operator key change, makes + /// it ExtAddr with an empty network info: Core prints its platform ports + /// as 0 and no `addresses`. Earlier binaries accept that diff, so every + /// node must build the validator they build from the legacy fields: a + /// banned member on the unspecified IP with ports 0. A node that kept the + /// evonode's `addresses` in memory and a node that restarted must both + /// build it, because validator-set membership decides quorum rotation. + #[test] + fn should_agree_on_the_validator_after_a_legacy_evonode_is_revoked_whether_or_not_the_node_restarted( + ) { + #[allow(deprecated)] + let revoke = DMNStateDiff { + service: Some("[::]:0".parse().expect("socket address")), + pose_ban_height: Some(Some(2)), + revocation_reason: Some(1), + platform_node_id: Some([0u8; 20]), + pub_key_operator: Some(vec![1u8; 48]), + legacy_platform_p2p_port: Some(0), + legacy_platform_http_port: Some(0), + ..empty_state_diff() + }; + let kept = state_after_diffs(evonode(), vec![revoke.clone()]); + let restarted = state_after_diffs(reloaded(evonode()), vec![revoke]); + + let pro_tx_hash = evonode_pro_tx_hash(); + let new_quorum_validator = ValidatorV0 { + pro_tx_hash, + public_key: None, + node_ip: "::".to_string(), + node_id: PubkeyHash::from_byte_array([0u8; 20]), + core_port: 0, + platform_http_port: 0, + platform_p2p_port: 0, + is_banned: true, + }; + // A refresh of an existing member takes the ban, the IP and the ports + // from the diff, and keeps its node id and core port. + let refreshed_member = ValidatorV0 { + node_id: PubkeyHash::from_byte_array([7u8; 20]), + core_port: 1234, + ..new_quorum_validator.clone() + }; + for state in [&kept, &restarted] { + assert_eq!( + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, state), + Some(new_quorum_validator.clone()) + ); + assert_eq!(validator_in(state), refreshed_member); + } + let stored = |state: &PlatformState| { + MasternodeV0::from(state.full_masternode_list()[&pro_tx_hash].clone()).state + }; + assert_eq!(stored(&kept), stored(&restarted)); + } + + /// When Core resets an ExtAddr evonode's operator fields (ProUpRevTx, or + /// a ProUpRegTx that changes the operator key), its network info becomes + /// empty: the diff has `service` `[::]:0` and no `addresses` key, so the + /// platform ports keep resolving to the old endpoint. That endpoint is + /// never advertised, because Core bans the masternode in the same + /// transition and only a ProUpServTx, which sends new `addresses`, revives + /// it. The evonode stays a member, banned, with the ports it last had. + #[test] + fn should_not_advertise_an_evonode_whose_network_info_core_emptied() { + let state = state_after_diffs( + evonode_without_legacy_ports(), + vec![DMNStateDiff { + service: Some("[::]:0".parse().expect("socket address")), + pose_ban_height: Some(Some(2)), + revocation_reason: Some(1), + platform_node_id: Some([0u8; 20]), + pub_key_operator: Some(vec![1u8; 48]), + ..empty_state_diff() + }], + ); + + let validator_set = + &state.validator_sets()[&QuorumHash::from_byte_array(VALIDATOR_QUORUM_HASH)]; + let new_quorum_validator = ValidatorV0 { + pro_tx_hash: evonode_pro_tx_hash(), + public_key: None, + node_ip: "::".to_string(), + node_id: PubkeyHash::from_byte_array([0u8; 20]), + core_port: 0, + platform_http_port: 443, + platform_p2p_port: 36656, + is_banned: true, + }; + assert_eq!( + validator_set.members()[&evonode_pro_tx_hash()], + ValidatorV0 { + node_id: PubkeyHash::from_byte_array([7u8; 20]), + core_port: 1234, + ..new_quorum_validator.clone() + } + ); + assert!( + validator_set.to_update().validator_updates.is_empty(), + "a banned validator is left out of the validator set update" + ); + for validator in validators_for_a_new_quorum(&state) { + assert_eq!( + validator, + Some(new_quorum_validator.clone()), + "a validator set built later gets the same banned member" + ); + } + } +} + +#[cfg(test)] +mod port_resolution_tests { + use super::in_stored_form; + use crate::config::PlatformConfig; + use crate::platform_types::platform_state::{PlatformState, PlatformStateV0Methods}; + use crate::platform_types::validator::v0::{NewValidatorIfMasternodeInState, ValidatorV0}; + use dpp::dashcore::hashes::Hash; + use dpp::dashcore::{Network, Txid}; + use dpp::dashcore::{ProTxHash, PubkeyHash}; + use dpp::dashcore_rpc::json::{DMNState, MasternodeListItem}; + use dpp::dashcore_rpc::json::{MasternodeAddresses, MasternodeType}; + use dpp::version::PlatformVersion; + + const PRO_TX_HASH: [u8; 32] = [0x77u8; 32]; + + /// An evonode registered at 1.2.3.4 with the given legacy platform ports + /// and nested addresses. + fn evonode_state( + legacy_platform_p2p_port: Option, + legacy_platform_http_port: Option, + addresses: Option, + ) -> DMNState { + #[allow(deprecated)] + DMNState { + service: "1.2.3.4:9999".parse().expect("socket address"), + registered_height: 0, + pose_revived_height: None, + pose_ban_height: None, + revocation_reason: 0, + owner_address: Some([0u8; 20]), + voting_address: [0u8; 20], + payout_address: Some([0u8; 20]), + payouts: None, + pub_key_operator: vec![0u8; 48], + operator_payout_address: None, + platform_node_id: Some([7u8; 20]), + legacy_platform_p2p_port, + legacy_platform_http_port, + addresses, + } + } + + fn platform_addresses(p2p: &str, https: &str) -> MasternodeAddresses { + MasternodeAddresses { + core_p2p: vec!["1.2.3.4:9999".to_string()], + platform_p2p: vec![p2p.to_string()], + platform_https: vec![https.to_string()], + } + } + + fn validator_for(dmn_state: DMNState) -> Option { + let platform_version = PlatformVersion::latest(); + let mut state = PlatformState::default_with_protocol_versions( + platform_version.protocol_version, + platform_version.protocol_version, + &PlatformConfig::default_for_network(Network::Testnet), + ) + .expect("platform state"); + let pro_tx_hash = ProTxHash::from_byte_array(PRO_TX_HASH); + state.insert_masternode(MasternodeListItem { + node_type: MasternodeType::Evo, + pro_tx_hash, + collateral_hash: Txid::from_byte_array([0u8; 32]), + collateral_index: 0, + collateral_address: Some([0u8; 20]), + operator_reward: 0.0, + state: in_stored_form(dmn_state), + }); + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, &state) + } + + /// An ExtAddr evonode keeps its platform ports in its network info; its + /// legacy port fields stay zero. + #[test] + fn should_take_platform_ports_from_addresses_when_legacy_ports_are_zero() { + let validator = validator_for(evonode_state( + Some(0), + Some(0), + Some(platform_addresses("1.2.3.4:36656", "1.2.3.4:443")), + )) + .expect("the evonode has platform ports"); + + assert_eq!(validator.platform_p2p_port, 36656); + assert_eq!(validator.platform_http_port, 443); + } + + /// A state whose legacy ports are absent takes its ports from + /// `addresses`. + #[test] + fn should_take_platform_ports_from_addresses_when_legacy_ports_are_absent() { + let validator = validator_for(evonode_state( + None, + None, + Some(platform_addresses("1.2.3.4:36656", "1.2.3.4:443")), + )) + .expect("the evonode has platform ports"); + + assert_eq!(validator.platform_p2p_port, 36656); + assert_eq!(validator.platform_http_port, 443); + } + + /// The validator is advertised on the core IP from `service`, whatever + /// host `addresses` names for the platform services: a legacy evonode's + /// port-only diff pairs the port with the placeholder host + /// 255.255.255.255. + #[test] + fn should_advertise_the_service_ip_whatever_host_addresses_name() { + let validator = validator_for(evonode_state( + Some(36656), + Some(443), + Some(platform_addresses( + "255.255.255.255:36656", + "203.0.113.7:443", + )), + )) + .expect("the evonode has platform ports"); + + assert_eq!(validator.node_ip, "1.2.3.4"); + assert_eq!(validator.core_port, 9999); + } + + /// Core before v23 lists no nested addresses; the legacy ports apply. + #[test] + fn should_take_legacy_ports_without_addresses() { + let validator = validator_for(evonode_state(Some(26656), Some(443), None)) + .expect("the evonode has platform ports"); + + assert_eq!(validator.node_ip, "1.2.3.4"); + assert_eq!(validator.platform_p2p_port, 26656); + assert_eq!(validator.platform_http_port, 443); + } + + /// Validator-set membership decides quorum rotation, so it must not + /// depend on how a node reads a port: an evonode whose legacy ports are 0 + /// and that lists no nested ports stays a validator, with those ports. + #[test] + fn should_keep_an_evonode_with_zero_legacy_ports_as_a_validator() { + let validator = validator_for(evonode_state(Some(0), Some(0), None)) + .expect("membership does not depend on the port value"); + + assert_eq!(validator.platform_p2p_port, 0); + assert_eq!(validator.platform_http_port, 0); + } + + /// A revoked legacy evonode as Core lists it with + /// `-deprecatedrpc=service`: its network info is empty, so `service` is + /// `[::]:0` and `addresses` has no platform entry, while the legacy port + /// fields keep the ports it was registered with. + fn revoked_legacy_evonode_state(addresses: &str) -> DMNState { + serde_json::from_str(&format!( + r#"{{ + "service": "[::]:0", + "addresses": {addresses}, + "registeredHeight": 100, + "PoSeRevivedHeight": -1, + "PoSeBanHeight": 200, + "revocationReason": 1, + "ownerAddress": "yPBWCdMRY5PsS3hJzs7csbdWQVRR85yxUz", + "votingAddress": "ySM11LUD65Bi4p1gm68XLkdWc65TBKRzvQ", + "payoutAddress": "yX4Ve7Q8Y4jscV4LZJD8HVCHKyePzR3MhA", + "pubKeyOperator": "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "platformNodeID": "0000000000000000000000000000000000000000", + "platformP2PPort": 26656, + "platformHTTPPort": 443 + }}"# + )) + .expect("Core's JSON for a revoked evonode") + } + + /// Whether an evonode is a validator decides quorum rotation, so every + /// node must build the same member for it. For an evonode whose listed + /// `addresses` hold no platform entry, that is the member the legacy + /// port fields alone give: banned, on the unspecified IP, with its + /// registered ports. + #[test] + fn should_build_a_revoked_legacy_evonode_from_its_legacy_ports() { + for addresses in [r#"{}"#, r#"{"core_p2p": []}"#] { + let validator = validator_for(revoked_legacy_evonode_state(addresses)); + + assert_eq!( + validator, + Some(ValidatorV0 { + pro_tx_hash: ProTxHash::from_byte_array(PRO_TX_HASH), + public_key: None, + node_ip: "::".to_string(), + node_id: PubkeyHash::from_byte_array([0u8; 20]), + core_port: 0, + platform_http_port: 443, + platform_p2p_port: 26656, + is_banned: true, + }), + "addresses: {addresses}" + ); + } + } +} diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/v1/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/v1/mod.rs new file mode 100644 index 00000000000..c25f87a1cc6 --- /dev/null +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/v1/mod.rs @@ -0,0 +1,97 @@ +use crate::error::Error; +use crate::execution::types::update_state_masternode_list_outcome; +use crate::platform_types::platform::Platform; +use crate::platform_types::platform_state::PlatformState; +use crate::platform_types::platform_state::PlatformStateV0Methods; +use crate::rpc::core::CoreRPCLike; +use dpp::block::block_info::BlockInfo; +use dpp::block::extended_block_info::v0::ExtendedBlockInfoV0Getters; +use dpp::version::PlatformVersion; +use drive::grovedb::Transaction; + +impl Platform +where + C: CoreRPCLike, +{ + /// Updates the masternode list in the platform state based on changes in the masternode list + /// from Dash Core between two block heights. + /// + /// This function fetches the masternode list difference between the current core block height + /// and the previous core block height, then updates the full masternode list and the + /// HPMN (high performance masternode) list in the platform state accordingly. + /// + /// # Arguments + /// + /// * `platform_state` - The optional committed platform state used for identity updates. + /// * `block_platform_state` - The mutable platform state for the block being executed. + /// * `core_block_height` - The current block height in the Dash Core. + /// * `is_init_chain` - Whether the update is initializing the chain. + /// * `block_info` - The block information used for identity updates. + /// * `transaction` - The current groveDB transaction. + /// * `platform_version` - The protocol version governing the update. + /// + /// # Returns + /// + /// * `Result<(), Error>` - Returns `Ok(())` if the update is successful. Returns an error if + /// there is a problem fetching the masternode list difference or updating the state. + #[allow(clippy::too_many_arguments)] + pub(super) fn update_masternode_list_v1( + &self, + platform_state: Option<&PlatformState>, + block_platform_state: &mut PlatformState, + core_block_height: u32, + is_init_chain: bool, + block_info: &BlockInfo, + transaction: &Transaction, + platform_version: &PlatformVersion, + ) -> Result<(), Error> { + if let Some(last_committed_block_info) = + block_platform_state.last_committed_block_info().as_ref() + { + if core_block_height == last_committed_block_info.basic_info().core_height { + tracing::debug!( + method = "update_masternode_list_v1", + "no update mnl at height {}", + core_block_height, + ); + return Ok(()); // no need to do anything + } + } + tracing::debug!( + method = "update_masternode_list_v1", + "update mnl to height {} at block {}", + core_block_height, + block_platform_state.last_committed_core_height() + ); + + let update_state_masternode_list_outcome::v0::UpdateStateMasternodeListOutcome { + masternode_list_diff, + removed_masternodes, + } = self.update_state_masternode_list_v1( + block_platform_state, + core_block_height, + is_init_chain, + )?; + + self.update_masternode_identities( + masternode_list_diff, + &removed_masternodes, + block_info, + platform_state, + transaction, + platform_version, + )?; + + if !removed_masternodes.is_empty() { + self.drive.remove_validators_proposed_app_versions( + removed_masternodes + .into_keys() + .map(|pro_tx_hash| pro_tx_hash.into()), + Some(transaction), + &platform_version.drive, + )?; + } + + Ok(()) + } +} diff --git a/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/versioning_tests.rs b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/versioning_tests.rs new file mode 100644 index 00000000000..345db4744cd --- /dev/null +++ b/packages/rs-drive-abci/src/execution/platform_events/core_based_updates/update_masternode_list/versioning_tests.rs @@ -0,0 +1,170 @@ +use crate::platform_types::platform_state::PlatformStateV0Methods; +use crate::platform_types::validator::v0::{NewValidatorIfMasternodeInState, ValidatorV0}; +use crate::test::helpers::setup::TestPlatformBuilder; +use dpp::block::block_info::BlockInfo; +use dpp::dashcore_rpc::json::{MasternodeAddresses, MasternodeListDiff}; +use dpp::version::PlatformVersion; +use serde_json::json; + +/// An RPC response with legacy identity fields so the port version gate is +/// exercised independently of the owner-identity version gate. +fn conflicting_ports() -> MasternodeListDiff { + let mut diff: MasternodeListDiff = serde_json::from_str(include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1-1000.json" + ))) + .expect("masternode fixture"); + assert_eq!(diff.added_mns.len(), 1); + let state = &mut diff.added_mns[0].state; + #[allow(deprecated)] + { + state.legacy_platform_p2p_port = Some(26656); + state.legacy_platform_http_port = Some(443); + } + state.addresses = Some(MasternodeAddresses { + core_p2p: vec![state.service.to_string()], + platform_p2p: vec!["192.0.2.40:36656".to_string()], + platform_https: vec!["192.0.2.40:8443".to_string()], + }); + diff +} + +#[test] +fn should_use_nested_ports_only_after_the_protocol_upgrade() { + for (platform_version, expected_ports) in [ + (PlatformVersion::get(13).expect("PV13"), (26656, 443)), + (PlatformVersion::latest(), (36656, 8443)), + ] { + let diff = conflicting_ports(); + let pro_tx_hash = diff.added_mns[0].pro_tx_hash; + let mut platform = TestPlatformBuilder::new() + .with_initial_protocol_version(platform_version.protocol_version) + .build_with_mock_rpc() + .set_genesis_state(); + let update = MasternodeListDiff { + base_height: 1000, + block_height: 2000, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![( + pro_tx_hash, + serde_json::from_value(json!({ + "addresses": { "platform_p2p": ["192.0.2.40:36657"] } + })) + .expect("nested-only diff"), + )], + }; + let flat_update = MasternodeListDiff { + base_height: 2000, + block_height: 2001, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![( + pro_tx_hash, + serde_json::from_value(json!({ + "platformP2PPort": 27656, + "platformHTTPPort": 1443 + })) + .expect("flat-only diff"), + )], + }; + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .returning(move |_, block| { + Ok(if block == 1000 { + diff.clone() + } else if block == 2000 { + update.clone() + } else { + flat_update.clone() + }) + }); + let mut state = platform.state.load().as_ref().clone(); + let transaction = platform.drive.grove.start_transaction(); + platform + .update_masternode_list( + None, + &mut state, + 1000, + true, + &BlockInfo::default(), + &transaction, + platform_version, + ) + .expect("update masternode list"); + let validator = + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, &state) + .expect("validator"); + assert_eq!( + (validator.platform_p2p_port, validator.platform_http_port), + expected_ports, + "protocol version {}", + platform_version.protocol_version + ); + #[allow(deprecated)] + let stored_ports = ( + state.hpmn_masternode_list()[&pro_tx_hash] + .state + .legacy_platform_p2p_port, + state.hpmn_masternode_list()[&pro_tx_hash] + .state + .legacy_platform_http_port, + ); + assert_eq!( + stored_ports, + (Some(expected_ports.0.into()), Some(expected_ports.1.into())) + ); + + let previous_state = state.clone(); + platform + .update_masternode_list( + Some(&previous_state), + &mut state, + 2000, + false, + &BlockInfo::default(), + &transaction, + platform_version, + ) + .expect("nested-only update"); + let validator = + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, &state) + .expect("updated validator"); + assert_eq!( + (validator.platform_p2p_port, validator.platform_http_port), + ( + if platform_version.protocol_version == 13 { + 26656 + } else { + 36657 + }, + expected_ports.1 + ), + "nested-only diff at protocol version {}", + platform_version.protocol_version, + ); + + let previous_state = state.clone(); + platform + .update_masternode_list( + Some(&previous_state), + &mut state, + 2001, + false, + &BlockInfo::default(), + &transaction, + platform_version, + ) + .expect("flat-only update"); + let validator = + ValidatorV0::new_validator_if_masternode_in_state(pro_tx_hash, None, &state) + .expect("updated validator"); + assert_eq!( + (validator.platform_p2p_port, validator.platform_http_port), + (27656, 1443), + "flat-only diff at protocol version {}", + platform_version.protocol_version, + ); + } +} diff --git a/packages/rs-drive-abci/src/platform_types/validator_set/v0/mod.rs b/packages/rs-drive-abci/src/platform_types/validator_set/v0/mod.rs index b63af8af882..4d639f64c1a 100644 --- a/packages/rs-drive-abci/src/platform_types/validator_set/v0/mod.rs +++ b/packages/rs-drive-abci/src/platform_types/validator_set/v0/mod.rs @@ -2,7 +2,7 @@ use crate::error::execution::ExecutionError; use crate::error::Error; use dpp::dashcore::hashes::Hash; -use dpp::dashcore::ProTxHash; +use dpp::dashcore::{ProTxHash, PubkeyHash}; use crate::platform_types::platform_state::PlatformState; use crate::platform_types::validator::v0::NewValidatorIfMasternodeInState; @@ -11,6 +11,7 @@ use dpp::core_types::validator::v0::ValidatorV0; pub use dpp::core_types::validator_set::v0::*; use dpp::dashcore_rpc::json::QuorumInfoResult; use std::collections::BTreeMap; +use std::net::{IpAddr, SocketAddr}; use tenderdash_abci::proto::abci::ValidatorSetUpdate; use tenderdash_abci::proto::crypto::public_key::Sum::Bls12381; use tenderdash_abci::proto::{abci, crypto}; @@ -91,12 +92,8 @@ impl ValidatorSetMethodsV0 for ValidatorSetV0 { if *is_banned { None } else { - let node_address = format!( - "tcp://{}@{}:{}", - hex::encode(node_id.to_byte_array()), - node_ip, - platform_p2p_port - ); + let node_address = + validator_node_address(node_id, node_ip, *platform_p2p_port); Some(Ok(abci::ValidatorUpdate { pub_key: (*public_key).map(|public_key| crypto::PublicKey { @@ -121,12 +118,8 @@ impl ValidatorSetMethodsV0 for ValidatorSetV0 { if *is_banned { None } else { - let node_address = format!( - "tcp://{}@{}:{}", - hex::encode(node_id.to_byte_array()), - node_ip, - platform_p2p_port - ); + let node_address = + validator_node_address(node_id, node_ip, *platform_p2p_port); Some(Ok(abci::ValidatorUpdate { pub_key: (*public_key).map(|public_key| crypto::PublicKey { @@ -178,12 +171,7 @@ impl ValidatorSetMethodsV0 for ValidatorSetV0 { if *is_banned { return None; } - let node_address = format!( - "tcp://{}@{}:{}", - hex::encode(node_id.to_byte_array()), - node_ip, - platform_p2p_port - ); + let node_address = validator_node_address(node_id, node_ip, *platform_p2p_port); Some(abci::ValidatorUpdate { pub_key: public_key.as_ref().map(|public_key| crypto::PublicKey { sum: Some(Bls12381(public_key.0.to_compressed().to_vec())), @@ -224,12 +212,8 @@ impl ValidatorSetMethodsV0 for ValidatorSetV0 { if is_banned { return None; } - let node_address = format!( - "tcp://{}@{}:{}", - hex::encode(node_id.to_byte_array()), - node_ip, - platform_p2p_port - ); + let node_address = + validator_node_address(&node_id, &node_ip, platform_p2p_port); Some(abci::ValidatorUpdate { pub_key: public_key.map(|public_key| crypto::PublicKey { @@ -309,6 +293,25 @@ impl ValidatorSetMethodsV0 for ValidatorSetV0 { } } +/// The address Tenderdash dials a validator on: `tcp://@:`. +/// +/// Formatting the host and port as a socket address writes an IPv6 host in +/// brackets, as a URL authority requires. `node_ip` always holds a formatted +/// IP address; anything else is written as it is. This only formats Tenderdash's +/// dialing text; persisted validator membership, keys and the validator-set hash +/// do not depend on it, so every protocol version can use the same formatting. +fn validator_node_address(node_id: &PubkeyHash, node_ip: &str, platform_p2p_port: u16) -> String { + let host_port = match node_ip.parse::() { + Ok(ip) => SocketAddr::new(ip, platform_p2p_port).to_string(), + Err(_) => format!("{}:{}", node_ip, platform_p2p_port), + }; + format!( + "tcp://{}@{}", + hex::encode(node_id.to_byte_array()), + host_port + ) +} + #[cfg(test)] mod tests { use super::*; @@ -546,4 +549,57 @@ mod tests { // threshold_public_key is still present assert!(update.threshold_public_key.is_some()); } + + /// A set holding one validator, on `node_ip`. + fn set_with_validator_on(pro_tx_hash: ProTxHash, node_ip: &str) -> ValidatorSetV0 { + let validator = ValidatorV0 { + node_ip: node_ip.to_string(), + ..make_validator(pro_tx_hash, false) + }; + // Same seeds, so every such set shares its threshold key. + make_set(1, 100, 1, BTreeMap::from([(pro_tx_hash, validator)])) + } + + /// Every node address Drive hands Tenderdash for a validator on `node_ip`: + /// from `to_update`, `to_update_owned`, and `update_difference` both when + /// the validator is unchanged and when it just moved there. + fn node_addresses_for_validator_on(node_ip: &str) -> Vec { + let pro_tx_hash = ProTxHash::from_byte_array([9; 32]); + let set = set_with_validator_on(pro_tx_hash, node_ip); + let before_the_move = set_with_validator_on(pro_tx_hash, "192.168.0.2"); + [ + set.to_update(), + set.clone().to_update_owned(), + set.update_difference(&set).expect("same quorum"), + before_the_move + .update_difference(&set) + .expect("same quorum"), + ] + .into_iter() + .map(|update| { + assert_eq!(update.validator_updates.len(), 1); + update.validator_updates[0].node_address.clone() + }) + .collect() + } + + /// A URL authority needs an IPv6 host in brackets (RFC 3986). Tenderdash + /// writes validator addresses that way; it only reads the unbracketed form + /// because Go's URL parser does not enforce this outside http(s). + #[test] + fn should_bracket_an_ipv6_host_in_the_validator_node_address() { + let expected = format!("tcp://{}@[2001:db8::1]:30", "07".repeat(20)); + for node_address in node_addresses_for_validator_on("2001:db8::1") { + assert_eq!(node_address, expected); + } + } + + /// An IPv4 host takes no brackets. + #[test] + fn should_write_an_ipv4_validator_node_address_without_brackets() { + let expected = format!("tcp://{}@192.168.0.1:30", "07".repeat(20)); + for node_address in node_addresses_for_validator_on("192.168.0.1") { + assert_eq!(node_address, expected); + } + } } diff --git a/packages/rs-drive-abci/tests/strategy_tests/test_cases/upgrade_fork_tests.rs b/packages/rs-drive-abci/tests/strategy_tests/test_cases/upgrade_fork_tests.rs index 3a91a25015f..32c52ba8b7f 100644 --- a/packages/rs-drive-abci/tests/strategy_tests/test_cases/upgrade_fork_tests.rs +++ b/packages/rs-drive-abci/tests/strategy_tests/test_cases/upgrade_fork_tests.rs @@ -3,16 +3,20 @@ mod tests { use crate::addresses_with_balance::AddressesWithBalance; use crate::execution::{continue_chain_for_strategy, run_chain_for_strategy, GENESIS_TIME_MS}; use crate::strategy::{ - ChainExecutionOutcome, ChainExecutionParameters, NetworkStrategy, StrategyRandomness, - UpgradingInfo, + ChainExecutionOutcome, ChainExecutionParameters, CoreHeightIncrease, NetworkStrategy, + StrategyRandomness, UpgradingInfo, }; use dash_platform_macros::stack_size; use dpp::block::epoch::Epoch; use dpp::block::extended_block_info::v0::ExtendedBlockInfoV0Getters; use dpp::block::extended_epoch_info::v0::ExtendedEpochInfoV0Getters; + use dpp::core_types::validator_set::v0::ValidatorSetV0Getters; use dpp::dashcore::hashes::Hash; use dpp::dashcore::Network::Regtest; - use dpp::dashcore::{BlockHash, ChainLock}; + use dpp::dashcore::{BlockHash, ChainLock, ProTxHash}; + use dpp::dashcore_rpc::dashcore_rpc_json::{ + DMNStateDiff, MasternodeAddresses, MasternodeListDiff, + }; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters; use dpp::data_contracts::SystemDataContract; @@ -26,6 +30,7 @@ mod tests { ValidatorSetConfig, }; use drive_abci::logging::LogLevel; + use drive_abci::platform_types::masternode::v0::MasternodeV0; use drive_abci::platform_types::platform::Platform; use drive_abci::platform_types::platform_state::PlatformStateV0Methods; use drive_abci::rpc::core::MockCoreRPCLike; @@ -34,6 +39,8 @@ mod tests { use platform_version::version::mocks::v3_test::TEST_PROTOCOL_VERSION_3; use platform_version::version::INITIAL_PROTOCOL_VERSION; use std::collections::BTreeMap; + use std::sync::atomic::{AtomicU32, Ordering}; + use std::sync::{Arc, Mutex}; use strategy_tests::{IdentityInsertInfo, StartAddresses, StartIdentities, Strategy}; #[stack_size(4 * 1024 * 1024)] @@ -1490,6 +1497,296 @@ mod tests { ); } + /// Nested addresses in an old node's memory are absent from its persisted masternode + /// entries. Activation and subsequent partial address diffs must therefore start from + /// the same stored ports whether the node kept running or restarted before activation. + #[stack_size(4 * 1024 * 1024)] + #[test] + async fn should_preserve_masternode_ports_across_activation_and_restart() { + const BLOCKS_PER_EPOCH: u64 = 60; + const NEW_P2P_PORT: u16 = 29999; + let previous_version = PlatformVersion::get(13).expect("protocol version 13"); + let latest_version = PlatformVersion::latest(); + let strategy = NetworkStrategy { + total_hpmns: 50, + validator_quorum_count: 24, + chain_lock_quorum_count: 24, + upgrading_info: Some(UpgradingInfo { + current_protocol_version: previous_version.protocol_version, + proposed_protocol_versions_with_weight: vec![(latest_version.protocol_version, 1)], + upgrade_three_quarters_life: 0.0, + }), + // Allocate mock Core block hashes through height 2; the explicit chain-lock + // expectation below controls when that second height becomes visible. + core_height_increase: CoreHeightIncrease::KnownCoreHeightIncreases(vec![1, 2]), + ..Default::default() + }; + let config = PlatformConfig { + validator_set: ValidatorSetConfig { + quorum_size: 30, + ..Default::default() + }, + chain_lock: ChainLockConfig::default_100_67(), + instant_lock: InstantLockConfig::default_100_67(), + execution: ExecutionConfig { + verify_sum_trees: true, + epoch_time_length_s: BLOCKS_PER_EPOCH, + ..Default::default() + }, + block_spacing_ms: 1_000, + testing_configs: PlatformTestConfig { + store_platform_state: true, + ..PlatformTestConfig::default_minimal_verifications() + }, + ..Default::default() + }; + let mut observations = Vec::new(); + for restart_before_activation in [false, true] { + let mut platform = TestPlatformBuilder::new() + .with_config(config.clone()) + .with_initial_protocol_version(previous_version.protocol_version) + .build_with_mock_rpc(); + let core_height = Arc::new(AtomicU32::new(1)); + let reported_core_height = Arc::clone(&core_height); + platform + .core_rpc + .expect_get_best_chain_lock() + .returning(move || { + Ok(ChainLock { + block_height: reported_core_height.load(Ordering::SeqCst), + block_hash: BlockHash::from_byte_array([1; 32]), + signature: [2; 96].into(), + }) + }); + let updated_masternode = Arc::new(Mutex::new(None::)); + let rpc_updated_masternode = Arc::clone(&updated_masternode); + platform + .core_rpc + .expect_get_protx_diff_with_masternodes() + .withf(|base_height, height| *base_height == Some(1) && *height == 2) + .returning(move |_, _| { + let pro_tx_hash = rpc_updated_masternode + .lock() + .expect("masternode fixture lock") + .expect("masternode fixture selected before Core advances"); + let state_diff: DMNStateDiff = serde_json::from_value(serde_json::json!({ + "addresses": { "platform_p2p": [format!("1.2.3.4:{NEW_P2P_PORT}")] } + })) + .expect("Core address diff"); + Ok(MasternodeListDiff { + base_height: 1, + block_height: 2, + added_mns: vec![], + removed_mns: vec![], + updated_mns: vec![(pro_tx_hash, state_diff)], + }) + }); + + let before_activation = run_chain_for_strategy( + &mut platform, + 2 * BLOCKS_PER_EPOCH, + strategy.clone(), + config.clone(), + 13, + &mut None, + &mut None, + ) + .await; + let committed_before_activation = + committed_upgrade_state(before_activation.abci_app.platform); + assert_eq!(committed_before_activation.epoch_index, 1); + assert_eq!(committed_before_activation.current_protocol_version, 13); + assert_eq!( + committed_before_activation.next_epoch_protocol_version, + latest_version.protocol_version + ); + let activation_parameters = continuation_parameters(&before_activation, 1); + let quorum_hash = before_activation.current_validator_quorum_hash; + let current_platform = before_activation.abci_app.platform; + let mut state = current_platform.state.load().as_ref().clone(); + let pro_tx_hash = *state.validator_sets()[&quorum_hash] + .members() + .keys() + .next() + .expect("populated validator set"); + *updated_masternode.lock().expect("masternode fixture lock") = Some(pro_tx_hash); + #[allow(deprecated)] + let original_ports = { + let masternode = &state.full_masternode_list()[&pro_tx_hash]; + ( + masternode + .state + .legacy_platform_p2p_port + .expect("legacy P2P port") as u16, + masternode + .state + .legacy_platform_http_port + .expect("legacy HTTPS port") as u16, + ) + }; + let transient_addresses = Some(MasternodeAddresses { + core_p2p: vec!["1.2.3.4:9999".to_string()], + platform_p2p: vec!["1.2.3.4:36656".to_string()], + platform_https: vec!["1.2.3.4:8443".to_string()], + }); + assert_ne!(original_ports, (36656, 8443)); + // Populate the raw old-protocol state deliberately: its RPC representation + // retains nested addresses, while the historical stored representation does not. + state + .full_masternode_list_mut() + .get_mut(&pro_tx_hash) + .expect("masternode") + .state + .addresses = transient_addresses.clone(); + state + .hpmn_masternode_list_mut() + .get_mut(&pro_tx_hash) + .expect("evonode") + .state + .addresses = transient_addresses; + let root_before_fixture = current_platform + .drive + .grove + .root_hash(None, &previous_version.drive.grove_version) + .unwrap() + .expect("stored root"); + current_platform + .store_platform_state(&state, None, previous_version) + .expect("persist old-protocol masternode fixture"); + assert_eq!( + current_platform + .drive + .grove + .root_hash(None, &previous_version.drive.grove_version) + .unwrap() + .expect("stored root after fixture"), + root_before_fixture, + "transient old-protocol addresses must not change persisted state" + ); + current_platform.state.store(Arc::new(state)); + drop(before_activation); + + if restart_before_activation { + let TempPlatform { + platform: mut old_platform, + tempdir, + } = platform; + let core_rpc = std::mem::take(&mut old_platform.core_rpc); + drop(old_platform); + platform = TempPlatform::open_with_tempdir(tempdir, config.clone()); + platform.platform.core_rpc = core_rpc; + assert!(platform.state.load().full_masternode_list()[&pro_tx_hash] + .state + .addresses + .is_none()); + } + assert_eq!( + committed_upgrade_state(&platform), + committed_before_activation + ); + + let activation = continue_chain_for_strategy( + FullAbciApplication::new(&platform), + activation_parameters, + strategy.clone(), + config.clone(), + StrategyRandomness::SeedEntropy(18), + ) + .await; + let activated = committed_upgrade_state(&platform); + assert_eq!(activated.epoch_index, 2); + assert_eq!( + activated.current_protocol_version, + latest_version.protocol_version + ); + assert_eq!( + activated.next_epoch_protocol_version, + latest_version.protocol_version + ); + assert_eq!( + platform.state.load().last_committed_core_height(), + 1, + "activation must also work without a Core-height advance" + ); + let ports = |platform: &Platform| { + let state = platform.state.load(); + let validator = &state.validator_sets()[&quorum_hash].members()[&pro_tx_hash]; + (validator.platform_p2p_port, validator.platform_http_port) + }; + assert_eq!(ports(&platform), original_ports); + let after_activation_parameters = continuation_parameters(&activation, 1); + drop(activation); + core_height.store(2, Ordering::SeqCst); + let after_update = continue_chain_for_strategy( + FullAbciApplication::new(&platform), + after_activation_parameters, + strategy.clone(), + config.clone(), + StrategyRandomness::SeedEntropy(19), + ) + .await; + assert_eq!(platform.state.load().last_committed_core_height(), 2); + assert_eq!( + ports(&platform), + (NEW_P2P_PORT, original_ports.1), + "a partial new-protocol diff must not restore transient pre-upgrade HTTPS ports" + ); + let state = platform.state.load(); + #[allow(deprecated)] + let stored_ports = { + let masternode = &state.full_masternode_list()[&pro_tx_hash]; + ( + masternode.state.legacy_platform_p2p_port, + masternode.state.legacy_platform_http_port, + ) + }; + assert_eq!( + stored_ports, + ( + Some(u32::from(NEW_P2P_PORT)), + Some(u32::from(original_ports.1)) + ) + ); + observations.push(( + committed_before_activation, + activated, + committed_upgrade_state(&platform), + state + .full_masternode_list() + .values() + .cloned() + .map(MasternodeV0::from) + .collect::>(), + state.validator_sets().clone(), + )); + drop(state); + drop(after_update); + let TempPlatform { + platform: old_platform, + tempdir, + } = platform; + drop(old_platform); + let reopened = TempPlatform::open_with_tempdir(tempdir, config.clone()); + let observed = observations.last().expect("recorded committed state"); + assert_eq!(committed_upgrade_state(&reopened), observed.2); + assert_eq!(ports(&reopened), (NEW_P2P_PORT, original_ports.1)); + let state = reopened.state.load(); + assert_eq!( + state + .full_masternode_list() + .values() + .cloned() + .map(MasternodeV0::from) + .collect::>(), + observed.3, + "post-activation restart must preserve all stored masternodes" + ); + assert_eq!(state.validator_sets(), &observed.4); + } + assert_eq!(observations[0], observations[1], + "live and restarted nodes must commit equal roots, stored masternodes and validator sets"); + } + #[stack_size(4 * 1024 * 1024)] #[test] #[ignore] // Long-running: runs in nightly CI only diff --git a/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/1260-1270.json b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/1260-1270.json new file mode 100644 index 00000000000..7611ce1aa1c --- /dev/null +++ b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/1260-1270.json @@ -0,0 +1,68 @@ +{ + "baseHeight": 1260, + "blockHeight": 1270, + "addedMNs": [ + { + "type": "Evo", + "proTxHash": "99e719c608d603658f296acd00f271345a29e391e2d717d3615062f9a961920c", + "collateralHash": "89b952e1ac0ecdf8245dc368c955a866538031c6685a562e579adeda25f7a8f3", + "collateralIndex": 0, + "collateralAddress": "yRuFRszcgUcV8jMEdg8MJ7Yync7GkNkp7d", + "operatorReward": 0, + "state": { + "version": 3, + "service": "4zmxpqirulb4blkyeufp3nd37wvcvpz6fibfwvgeybtfttkkni7h3mdd.onion:9999", + "addresses": { + "core_p2p": [ + "4zmxpqirulb4blkyeufp3nd37wvcvpz6fibfwvgeybtfttkkni7h3mdd.onion:9999" + ], + "platform_p2p": [ + "192.0.2.50:26656" + ], + "platform_https": [ + "192.0.2.50:443" + ] + }, + "registeredHeight": 1265, + "lastPaidHeight": 0, + "consecutivePayments": 0, + "PoSePenalty": 0, + "PoSeRevivedHeight": -1, + "PoSeBanHeight": -1, + "revocationReason": 0, + "ownerAddress": "yMWTGVez6o7YXsaj2cEGT9bU3a1jHbmDtJ", + "votingAddress": "ySM11LUD65Bi4p1gm68XLkdWc65TBKRzvQ", + "platformNodeID": "9cea9116b333eba7631804e1be7efd62c56d5b58", + "platformP2PPort": 26656, + "platformHTTPPort": 443, + "payouts": [ + { + "address": "yfzihVQvxhkkp4rTSw3sLYQzxbaifaTUTZ", + "script": "76a914d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d788ac", + "reward": 10000 + } + ], + "pubKeyOperator": "b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6" + } + } + ], + "removedMNs": [], + "updatedMNs": [ + { + "ca3d32c4f2ef62eaf736bf41bb3235a832ec1eb6d8dfaccd4d3555e70f6757b0": { + "service": "192.0.2.40:9999", + "addresses": { + "core_p2p": [ + "192.0.2.40:9999" + ], + "platform_p2p": [ + "192.0.2.40:36657" + ], + "platform_https": [ + "192.0.2.40:8443" + ] + } + } + } + ] +} diff --git a/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1-1000.json b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1-1000.json new file mode 100644 index 00000000000..311ade66dfd --- /dev/null +++ b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1-1000.json @@ -0,0 +1,45 @@ +{ + "baseHeight": 1, + "blockHeight": 1000, + "addedMNs": [ + { + "type": "Evo", + "proTxHash": "86e4a4274da5610322340e2f34adf8f6f2899f78b2ce1c31281b6d1754a88d76", + "collateralHash": "b881e375496b24e492820639e8dbe466b86af721eba6fcfdd5c9acf9d3e0afff", + "collateralIndex": 0, + "collateralAddress": "yRzZJpqMjbUdXCyCqHFUeU3vnJ2Z5Pzs3Q", + "operatorReward": 0, + "state": { + "version": 2, + "service": "192.0.2.60:9999", + "addresses": { + "core_p2p": [ + "192.0.2.60:9999" + ], + "platform_https": [ + "192.0.2.60:443" + ], + "platform_p2p": [ + "192.0.2.60:26656" + ] + }, + "registeredHeight": 900, + "lastPaidHeight": 990, + "consecutivePayments": 0, + "PoSePenalty": 0, + "PoSeRevivedHeight": -1, + "PoSeBanHeight": -1, + "revocationReason": 0, + "ownerAddress": "yMbm9SVj9uygvMChEDMPoW6R3Fw1fLRaRz", + "votingAddress": "ySM11LUD65Bi4p1gm68XLkdWc65TBKRzvQ", + "platformNodeID": "416e5b04d3047def070bea5175431ca7732b4b7b", + "platformP2PPort": 26656, + "platformHTTPPort": 443, + "payoutAddress": "yaQv7p9egV1wB22MEzZ8vyyAHcYWUTNndN", + "pubKeyOperator": "b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7" + } + } + ], + "removedMNs": [], + "updatedMNs": [] +} diff --git a/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1000-1010.json b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1000-1010.json new file mode 100644 index 00000000000..25b973d90b7 --- /dev/null +++ b/packages/rs-drive-abci/tests/supporting_files/core_v24_protx_list_diffs/before_v24/1000-1010.json @@ -0,0 +1,18 @@ +{ + "baseHeight": 1000, + "blockHeight": 1010, + "addedMNs": [], + "removedMNs": [], + "updatedMNs": [ + { + "86e4a4274da5610322340e2f34adf8f6f2899f78b2ce1c31281b6d1754a88d76": { + "platformP2PPort": 36657, + "addresses": { + "platform_p2p": [ + "255.255.255.255:36657" + ] + } + } + } + ] +} diff --git a/packages/rs-platform-version/src/version/drive_abci_versions/drive_abci_method_versions/v10.rs b/packages/rs-platform-version/src/version/drive_abci_versions/drive_abci_method_versions/v10.rs index 06bc0616f06..29c9e4a39ef 100644 --- a/packages/rs-platform-version/src/version/drive_abci_versions/drive_abci_method_versions/v10.rs +++ b/packages/rs-platform-version/src/version/drive_abci_versions/drive_abci_method_versions/v10.rs @@ -45,7 +45,7 @@ pub const DRIVE_ABCI_METHOD_VERSIONS_V10: DriveAbciMethodVersions = DriveAbciMet }, core_based_updates: DriveAbciCoreBasedUpdatesMethodVersions { update_core_info: 0, - update_masternode_list: 0, + update_masternode_list: 1, // resolves nested platform ports before storing masternodes update_quorum_info: 0, masternode_updates: DriveAbciMasternodeIdentitiesUpdatesMethodVersions { get_voter_identity_key: 0, diff --git a/packages/rs-platform-version/src/version/v14.rs b/packages/rs-platform-version/src/version/v14.rs index a78074591e8..de00adcd190 100644 --- a/packages/rs-platform-version/src/version/v14.rs +++ b/packages/rs-platform-version/src/version/v14.rs @@ -2008,6 +2008,16 @@ pub const PROTOCOL_VERSION_14: ProtocolVersion = 14; /// version must be active on a network before its Dash Core activates V24, /// since earlier versions keep failing on these masternodes. /// +/// 78. **Versioned Core masternode address resolution**: `update_masternode_list` 1 +/// resolves nested platform addresses first, then falls back to legacy ports, +/// before storing the masternode state. Earlier protocol versions keep their +/// flat-field interpretation. The stored layout and validator construction +/// remain unchanged: new validators read the resolved stored ports, and an +/// existing validator is refreshed on a ban, service or P2P-port change. +/// Each diff starts from the old persisted representation so transient address +/// data retained before activation cannot make a running node disagree with +/// a restarted one. Payout lists remain outside the persisted representation. +/// /// 80. **A BLS12_381 signature must verify**: `verify_identity_signed_signature` /// 1 (`STATE_TRANSITION_METHOD_VERSIONS_V2`), the signature check that /// identity-signature validation runs for every identity-signed diff --git a/packages/rs-sdk/tests/vectors/test_identity_read_v1/msg_IdentityRequest_df74c9ad751824ab66cbc44c0b9bae70cfdf255d4db7c291e9db395a8aa528ba.json b/packages/rs-sdk/tests/vectors/test_identity_read_v1/msg_IdentityRequest_df74c9ad751824ab66cbc44c0b9bae70cfdf255d4db7c291e9db395a8aa528ba.json new file mode 100644 index 00000000000..f99368fb16d Binary files /dev/null and b/packages/rs-sdk/tests/vectors/test_identity_read_v1/msg_IdentityRequest_df74c9ad751824ab66cbc44c0b9bae70cfdf255d4db7c291e9db395a8aa528ba.json differ diff --git a/packages/rs-sdk/tests/vectors/test_identity_read_v1/quorum_pubkey-6-0000003238798a94d4ae5f44409a538e83bc4d610211c3c45fc176b7d3f06b4d.json b/packages/rs-sdk/tests/vectors/test_identity_read_v1/quorum_pubkey-6-0000003238798a94d4ae5f44409a538e83bc4d610211c3c45fc176b7d3f06b4d.json new file mode 100644 index 00000000000..b7c03b0d039 --- /dev/null +++ b/packages/rs-sdk/tests/vectors/test_identity_read_v1/quorum_pubkey-6-0000003238798a94d4ae5f44409a538e83bc4d610211c3c45fc176b7d3f06b4d.json @@ -0,0 +1 @@ +a16e64068375ca0a085305c2b9a409ed85733f9398dfd2569a5238de20a47dec9a9ade493a0c428beb056fbfbdc13e5a \ No newline at end of file diff --git a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift index 95286587d54..4beee9638fa 100644 --- a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift +++ b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/DashModelMigrationTests.swift @@ -58,23 +58,6 @@ final class DashModelMigrationTests: XCTestCase { return (directory, copy) } - /// `DashLegacyStoreSQLite.checkpoint`, retried while the store is still - /// locked. SwiftData closes a released container's SQLite connection - /// asynchronously, and `checkpoint` deliberately does not wait for locks, - /// so under load the first attempt can still meet that connection. Any - /// other failure, or a lock that outlasts ten seconds, is thrown. - private static func checkpointWhenUnlocked(_ url: URL) throws { - let deadline = Date().addingTimeInterval(10) - while true { - do { - return try DashLegacyStoreSQLite.checkpoint(url) - } catch DashLegacyStoreSQLite.Failure.database(let reason) - where reason == "database is locked" && Date() < deadline { - Thread.sleep(forTimeInterval: 0.01) - } - } - } - @MainActor func testMigrationDiagnosticsReachExportFileWithoutVerboseLogging() throws { let fixture = try XCTUnwrap(Self.fixtures.first { $0.name == "historical-v2" }) @@ -660,10 +643,11 @@ final class DashModelMigrationTests: XCTestCase { try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: directory) } let url = directory.appendingPathComponent("historical-v2.store") + let workingURL = directory.appendingPathComponent("working.store") try autoreleasepool { let schema = Schema(versionedSchema: DashSchemaV2.self) let container = try ModelContainer(for: schema, configurations: [ - ModelConfiguration(schema: schema, url: url, cloudKitDatabase: .none) + ModelConfiguration(schema: schema, url: workingURL, cloudKitDatabase: .none) ]) let context = container.mainContext let wallet = DashSchemaV2.PersistentWallet( @@ -719,8 +703,12 @@ final class DashModelMigrationTests: XCTestCase { networkRaw: Network.testnet.rawValue, proTxHash: Data(repeating: 7, count: 32), label: "fixture", addedAt: 1, snapshotJSON: "{}")) try context.save() + // Snapshot committed data while SwiftData still owns the WAL store. + try withExtendedLifetime(container) { + try DashLegacyStoreSQLite.copy(from: workingURL, to: url) + try DashLegacyStoreSQLite.validatePreservation(from: workingURL, to: url) + } } - try Self.checkpointWhenUnlocked(url) let metadata = try DashSchemaFixtureSupport.describeStore(at: url, version: Schema.Version(2, 0, 0)) XCTAssertEqual(metadata.entity_hashes.count, 35) XCTAssertEqual(metadata.model_checksum, "RrRj/iNbS9izgLQvNb2APed4iwaR7pftEE2+4tea7K8=") diff --git a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/SDKMethodTests.swift b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/SDKMethodTests.swift index 427cb640055..5d0d878d28f 100644 --- a/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/SDKMethodTests.swift +++ b/packages/swift-sdk/SwiftTests/SwiftDashSDKTests/SDKMethodTests.swift @@ -98,12 +98,34 @@ final class SDKMethodTests: XCTestCase { } } + /// Fetches an identity through `identityGet` from rs-sdk's recorded + /// `test_identity_read_v1` vectors: the mock replays the recorded DAPI + /// response, the SDK verifies its proof against the recorded quorum key, + /// and the identity is decoded into the Swift result. + @MainActor + func testSimpleIdentityFetch() async throws { + let vectors = Self.rsSdkVectors("test_identity_read_v1") + guard FileManager.default.fileExists(atPath: vectors) else { + XCTFail("missing rs-sdk offline vectors at \(vectors)") + return + } + + SDK.initialize() + let sdk = try SDK(mockVectorsDirectory: vectors) + + // The vectors contain a testnet identity with a GroveDB V1 proof. + let identityId = "5DbLwAxGBzUzo81VewMUwn4b5P4bpv9FNFybi25XB5Bk" + let identity = try await sdk.identityGet(identityId: identityId) + + XCTAssertEqual(identity["id"] as? String, identityId) + let publicKeys = try XCTUnwrap(identity["publicKeys"] as? [[String: Any]]) + XCTAssertFalse(publicKeys.isEmpty, "the recorded identity has public keys") + } + /// Fetches an identity's public keys through `identityGetKeys` from /// rs-sdk's recorded `test_identity_public_keys_all_read` vectors: the mock /// replays the recorded DAPI response, the SDK verifies its proof against /// the recorded quorum key, and the keys are decoded into the Swift result. - /// It does not read `test_identity_read`: those vectors carry GroveDB V0 - /// proof envelopes, which every client refuses since dashpay/platform#5294. @MainActor func testIdentityKeysFetch() async throws { let vectors = Self.rsSdkVectors("test_identity_public_keys_all_read")