chore: system data contracts versioning

packages/bench-suite/benchmarks/basicValidation.js

@@ -1,6 +1,6 @@
 const { PrivateKey } = require('@dashevo/dashcore-lib');
 
-const dpnsDocumentTypes = require('@dashevo/dpns-contract/schema/dpns-contract-documents');
+const dpnsDocumentTypes = require('@dashevo/dpns-contract/schema/v1/dpns-contract-documents.json');
 
 // const { DashPlatformProtocol, Identity, Identifier, default: loadWasmDpp }  = require('@dashevo/wasm-dpp');
 const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');

packages/bench-suite/benchmarks/documents/dpns.js

@@ -1,6 +1,6 @@
 const crypto = require('crypto');
 
-const dpnsDocumentTypes = require('@dashevo/dpns-contract/schema/dpns-contract-documents');
+const dpnsDocumentTypes = require('@dashevo/dpns-contract/schema/v1/dpns-contract-documents.json');
 
 const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');
 

packages/dashpay-contract/Cargo.toml

@@ -7,5 +7,7 @@ rust-version = "1.73"
 license = "MIT"
 
 [dependencies]
+platform-version = { path = "../rs-platform-version" }
+thiserror = "1.0.56"
 serde_json = { version = "1.0" }
 platform-value = { path = "../rs-platform-value" }

packages/dashpay-contract/src/error.rs

@@ -0,0 +1,17 @@
+use platform_version::version::FeatureVersion;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// Platform expected some specific versions
+    #[error("platform unknown version on {method}, received: {received}")]
+    UnknownVersionMismatch {
+        /// method
+        method: String,
+        /// the allowed versions for this method
+        known_versions: Vec<FeatureVersion>,
+        /// requested core height
+        received: FeatureVersion,
+    },
+    #[error("schema deserialize error: {0}")]
+    InvalidSchemaJson(#[from] serde_json::Error),
+}

packages/dashpay-contract/src/lib.rs

@@ -1,5 +1,9 @@
+mod error;
+pub mod v1;
+
+pub use crate::error::Error;
 use platform_value::{Identifier, IdentifierBytes32};
-use serde_json::Error;
+use platform_version::version::PlatformVersion;
 use serde_json::Value;
 
 pub const ID_BYTES: [u8; 32] = [
@@ -12,21 +16,26 @@ pub const OWNER_ID_BYTES: [u8; 32] = [
     215, 90, 101, 229, 15, 115, 5, 44, 117, 182, 217,
 ];
 
-pub mod document_types {
-    pub mod contact_request {
-        pub const NAME: &str = "contactRequest";
-
-        pub mod properties {
-            pub const TO_USER_ID: &str = "toUserId";
-            pub const CORE_HEIGHT_CREATED_AT: &str = "coreHeightCreatedAt";
-            pub const CORE_CHAIN_LOCKED_HEIGHT: &str = "coreChainLockedHeight";
-        }
-    }
-}
-
 pub const ID: Identifier = Identifier(IdentifierBytes32(ID_BYTES));
 pub const OWNER_ID: Identifier = Identifier(IdentifierBytes32(OWNER_ID_BYTES));
 
-pub fn load_documents_schemas() -> Result<Value, Error> {
-    serde_json::from_str(include_str!("../schema/dashpay.schema.json"))
+pub fn load_definitions(platform_version: &PlatformVersion) -> Result<Option<Value>, Error> {
+    match platform_version.system_data_contracts.dashpay {
+        1 => Ok(None),
+        version => Err(Error::UnknownVersionMismatch {
+            method: "dashpay_contract::load_definitions".to_string(),
+            known_versions: vec![1],
+            received: version,
+        }),
+    }
+}
+pub fn load_documents_schemas(platform_version: &PlatformVersion) -> Result<Value, Error> {
+    match platform_version.system_data_contracts.dashpay {
+        1 => v1::load_documents_schemas(),
+        version => Err(Error::UnknownVersionMismatch {
+            method: "dashpay_contract::load_documents_schemas".to_string(),
+            known_versions: vec![1],
+            received: version,
+        }),
+    }
 }

packages/dashpay-contract/src/v1/mod.rs

@@ -0,0 +1,19 @@
+use crate::error::Error;
+use serde_json::Value;
+
+pub mod document_types {
+    pub mod contact_request {
+        pub const NAME: &str = "contactRequest";
+
+        pub mod properties {
+            pub const TO_USER_ID: &str = "toUserId";
+            pub const CORE_HEIGHT_CREATED_AT: &str = "coreHeightCreatedAt";
+            pub const CORE_CHAIN_LOCKED_HEIGHT: &str = "coreChainLockedHeight";
+        }
+    }
+}
+
+pub fn load_documents_schemas() -> Result<Value, Error> {
+    serde_json::from_str(include_str!("../../schema/v1/dashpay.schema.json"))
+        .map_err(Error::InvalidSchemaJson)
+}

packages/dashpay-contract/test/unit/schema.spec.js

@@ -2,7 +2,7 @@ const { expect } = require('chai');
 const crypto = require('crypto');
 const { DashPlatformProtocol, JsonSchemaError } = require('@dashevo/wasm-dpp');
 const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');
-const schema = require('../../schema/dashpay.schema.json');
+const schema = require('../../schema/v1/dashpay.schema.json');
 
 const whitepaperMasternodeText = 'Full nodes are servers running on a P2P network that allow peers to use them to receive updates about the events on the network. These nodes utilize significant amounts of traffic and other resources that incur a substantial cost. As a result, a steady decrease in the amount of these nodes has been observed for some time on the Bitcoin network and as a result, block propagation times have been upwards of 40 seconds. Many solutions have been proposed such as a new reward scheme by Microsoft Research and the Bitnodes incentive program';
 const encoded32Chars = '4fafc98bbfe597f7ba2c9f767d52036d';

packages/data-contracts/Cargo.toml

@@ -7,6 +7,8 @@ rust-version = "1.73"
 license = "MIT"
 
 [dependencies]
+thiserror = "1.0.56"
+platform-version = { path = "../rs-platform-version" }
 serde_json = { version = "1.0" }
 withdrawals-contract = { path = "../withdrawals-contract" }
 masternode-reward-shares-contract = { path = "../masternode-reward-shares-contract" }

packages/data-contracts/src/error.rs

@@ -0,0 +1,104 @@
+use platform_version::version::FeatureVersion;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// Platform expected some specific versions
+    #[error("platform unknown version on {method}, received: {received}")]
+    UnknownVersionMismatch {
+        /// method
+        method: String,
+        /// the allowed versions for this method
+        known_versions: Vec<FeatureVersion>,
+        /// requested core height
+        received: FeatureVersion,
+    },
+    #[error("schema deserialize error: {0}")]
+    InvalidSchemaJson(#[from] serde_json::Error),
+}
+
+impl From<withdrawals_contract::Error> for Error {
+    fn from(e: withdrawals_contract::Error) -> Self {
+        match e {
+            withdrawals_contract::Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            } => Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            },
+            withdrawals_contract::Error::InvalidSchemaJson(e) => Error::InvalidSchemaJson(e),
+        }
+    }
+}
+
+impl From<dashpay_contract::Error> for Error {
+    fn from(e: dashpay_contract::Error) -> Self {
+        match e {
+            dashpay_contract::Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            } => Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            },
+            dashpay_contract::Error::InvalidSchemaJson(e) => Error::InvalidSchemaJson(e),
+        }
+    }
+}
+
+impl From<dpns_contract::Error> for Error {
+    fn from(e: dpns_contract::Error) -> Self {
+        match e {
+            dpns_contract::Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            } => Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            },
+            dpns_contract::Error::InvalidSchemaJson(e) => Error::InvalidSchemaJson(e),
+        }
+    }
+}
+
+impl From<masternode_reward_shares_contract::Error> for Error {
+    fn from(e: masternode_reward_shares_contract::Error) -> Self {
+        match e {
+            masternode_reward_shares_contract::Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            } => Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            },
+            masternode_reward_shares_contract::Error::InvalidSchemaJson(e) => {
+                Error::InvalidSchemaJson(e)
+            }
+        }
+    }
+}
+
+impl From<feature_flags_contract::Error> for Error {
+    fn from(e: feature_flags_contract::Error) -> Self {
+        match e {
+            feature_flags_contract::Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            } => Error::UnknownVersionMismatch {
+                method,
+                known_versions,
+                received,
+            },
+            feature_flags_contract::Error::InvalidSchemaJson(e) => Error::InvalidSchemaJson(e),
+        }
+    }
+}

packages/data-contracts/src/lib.rs

@@ -1,14 +1,18 @@
-use serde_json::{Error, Value};
+mod error;
 
+use serde_json::Value;
+
+use crate::error::Error;
 pub use dashpay_contract;
 pub use dpns_contract;
 pub use feature_flags_contract;
 pub use masternode_reward_shares_contract;
 use platform_value::Identifier;
+use platform_version::version::PlatformVersion;
 pub use withdrawals_contract;
 
 #[repr(u8)]
-#[derive(PartialEq, Eq, Clone, Copy, Debug, Ord, PartialOrd)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Ord, PartialOrd, Hash)]
 pub enum SystemDataContract {
     Withdrawals = 0,
     MasternodeRewards = 1,
@@ -20,6 +24,7 @@ pub enum SystemDataContract {
 pub struct DataContractSource {
     pub id_bytes: [u8; 32],
     pub owner_id_bytes: [u8; 32],
+    pub version: u32,
     pub definitions: Option<Value>,
     pub document_schemas: Value,
 }
@@ -36,37 +41,46 @@ impl SystemDataContract {
         Identifier::new(bytes)
     }
     /// Returns [DataContractSource]
-    pub fn source(self) -> Result<DataContractSource, Error> {
+    pub fn source(self, platform_version: &PlatformVersion) -> Result<DataContractSource, Error> {
         let data = match self {
             SystemDataContract::Withdrawals => DataContractSource {
                 id_bytes: withdrawals_contract::ID_BYTES,
                 owner_id_bytes: withdrawals_contract::OWNER_ID_BYTES,
-                definitions: None,
-                document_schemas: withdrawals_contract::load_documents_schemas()?,
+                version: platform_version.system_data_contracts.withdrawals as u32,
+                definitions: withdrawals_contract::load_definitions(platform_version)?,
+                document_schemas: withdrawals_contract::load_documents_schemas(platform_version)?,
             },
             SystemDataContract::MasternodeRewards => DataContractSource {
                 id_bytes: masternode_reward_shares_contract::ID_BYTES,
                 owner_id_bytes: masternode_reward_shares_contract::OWNER_ID_BYTES,
-                definitions: None,
-                document_schemas: masternode_reward_shares_contract::load_documents_schemas()?,
+                version: platform_version
+                    .system_data_contracts
+                    .masternode_reward_shares as u32,
+                definitions: withdrawals_contract::load_definitions(platform_version)?,
+                document_schemas: masternode_reward_shares_contract::load_documents_schemas(
+                    platform_version,
+                )?,
             },
             SystemDataContract::FeatureFlags => DataContractSource {
                 id_bytes: feature_flags_contract::ID_BYTES,
                 owner_id_bytes: feature_flags_contract::OWNER_ID_BYTES,
-                definitions: None,
-                document_schemas: feature_flags_contract::load_documents_schemas()?,
+                version: platform_version.system_data_contracts.feature_flags as u32,
+                definitions: feature_flags_contract::load_definitions(platform_version)?,
+                document_schemas: feature_flags_contract::load_documents_schemas(platform_version)?,
             },
             SystemDataContract::DPNS => DataContractSource {
                 id_bytes: dpns_contract::ID_BYTES,
                 owner_id_bytes: dpns_contract::OWNER_ID_BYTES,
-                definitions: None,
-                document_schemas: dpns_contract::load_documents_schemas()?,
+                version: platform_version.system_data_contracts.dpns as u32,
+                definitions: dpns_contract::load_definitions(platform_version)?,
+                document_schemas: dpns_contract::load_documents_schemas(platform_version)?,
             },
             SystemDataContract::Dashpay => DataContractSource {
                 id_bytes: dashpay_contract::ID_BYTES,
                 owner_id_bytes: dashpay_contract::OWNER_ID_BYTES,
-                definitions: None,
-                document_schemas: dashpay_contract::load_documents_schemas()?,
+                version: platform_version.system_data_contracts.dashpay as u32,
+                definitions: dashpay_contract::load_definitions(platform_version)?,
+                document_schemas: dashpay_contract::load_documents_schemas(platform_version)?,
             },
         };
 

packages/dpns-contract/Cargo.toml

@@ -7,5 +7,7 @@ rust-version = "1.73"
 license = "MIT"
 
 [dependencies]
+thiserror = "1.0.56"
+platform-version = { path = "../rs-platform-version" }
 serde_json = { version = "1.0" }
 platform-value = { path = "../rs-platform-value" }