Merge branch 'deployment-0.9.30' into payouts-random-tests

node/service/chain-specs/example.json

@@ -187,13 +187,15 @@
                 46,
                 49
               ],
+              "domain": [],
+              "ssl": false,
               "http_port": 8080,
               "grpc_port": 8081,
               "p2p_port": 8082,
               "mode": "Storage"
             }
           }
-        ],
+        ]
       },
       "ddcClusters": {
         "clusters": [
@@ -233,6 +235,16 @@
             ]
           ]
         ]
+      },
+      "ddcPayouts": {
+        "authorisedCaller": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+        "debtorCustomers": [
+          [
+            "0x0000000000000000000000000000000000000001",
+            "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+            10000000000
+          ]
+        ]
       }
     }
   }

pallets/ddc-clusters/src/testing_utils.rs

@@ -55,7 +55,9 @@ where
 	let cluster_params = ClusterParams { node_provider_auth_contract: Some(user.clone()) };
 	let storage_node_params = StorageNodeParams {
 		mode: StorageNodeMode::Storage,
-		host: vec![1u8, 255],
+		host: vec![1u8; 255],
+		domain: vec![2u8; 255],
+		ssl: true,
 		http_port: 35000u16,
 		grpc_port: 25000u16,
 		p2p_port: 15000u16,

pallets/ddc-clusters/src/tests.rs

@@ -57,6 +57,51 @@ fn create_cluster_works() {
 			cluster_gov_params.clone()
 		));
 
+		let created_cluster = DdcClusters::clusters(cluster_id).unwrap();
+		assert_eq!(created_cluster.cluster_id, cluster_id);
+		assert_eq!(created_cluster.manager_id, cluster_manager_id);
+		assert_eq!(created_cluster.reserve_id, cluster_reserve_id);
+		assert_eq!(created_cluster.props.node_provider_auth_contract, Some(auth_contract.clone()));
+
+		let created_cluster_gov_params = DdcClusters::clusters_gov_params(cluster_id).unwrap();
+		assert_eq!(created_cluster_gov_params.treasury_share, cluster_gov_params.treasury_share);
+		assert_eq!(
+			created_cluster_gov_params.validators_share,
+			cluster_gov_params.validators_share
+		);
+		assert_eq!(
+			created_cluster_gov_params.cluster_reserve_share,
+			cluster_gov_params.cluster_reserve_share
+		);
+		assert_eq!(
+			created_cluster_gov_params.storage_bond_size,
+			cluster_gov_params.storage_bond_size
+		);
+		assert_eq!(
+			created_cluster_gov_params.storage_chill_delay,
+			cluster_gov_params.storage_chill_delay
+		);
+		assert_eq!(
+			created_cluster_gov_params.storage_unbonding_delay,
+			cluster_gov_params.storage_unbonding_delay
+		);
+		assert_eq!(
+			created_cluster_gov_params.unit_per_mb_stored,
+			cluster_gov_params.unit_per_mb_stored
+		);
+		assert_eq!(
+			created_cluster_gov_params.unit_per_mb_streamed,
+			cluster_gov_params.unit_per_mb_streamed
+		);
+		assert_eq!(
+			created_cluster_gov_params.unit_per_put_request,
+			cluster_gov_params.unit_per_put_request
+		);
+		assert_eq!(
+			created_cluster_gov_params.unit_per_get_request,
+			cluster_gov_params.unit_per_get_request
+		);
+
 		// Creating cluster with same id should fail
 		assert_noop!(
 			DdcClusters::create_cluster(
@@ -143,7 +188,9 @@ fn add_and_delete_node_works() {
 
 		let storage_node_params = StorageNodeParams {
 			mode: StorageNodeMode::Storage,
-			host: vec![1u8, 255],
+			host: vec![1u8; 255],
+			domain: vec![2u8; 255],
+			ssl: true,
 			http_port: 35000u16,
 			grpc_port: 25000u16,
 			p2p_port: 15000u16,
@@ -351,9 +398,12 @@ fn set_cluster_params_works() {
 		assert_ok!(DdcClusters::set_cluster_params(
 			RuntimeOrigin::signed(cluster_manager_id),
 			cluster_id,
-			ClusterParams { node_provider_auth_contract: Some(auth_contract_2) },
+			ClusterParams { node_provider_auth_contract: Some(auth_contract_2.clone()) },
 		));
 
+		let updated_cluster = DdcClusters::clusters(cluster_id).unwrap();
+		assert_eq!(updated_cluster.props.node_provider_auth_contract, Some(auth_contract_2));
+
 		// Checking that event was emitted
 		assert_eq!(System::events().len(), 2);
 		System::assert_last_event(Event::ClusterParamsSet { cluster_id }.into())
@@ -406,17 +456,69 @@ fn set_cluster_gov_params_works() {
 			DdcClusters::set_cluster_gov_params(
 				RuntimeOrigin::signed(cluster_manager_id),
 				cluster_id,
-				cluster_gov_params.clone()
+				cluster_gov_params
 			),
 			BadOrigin
 		);
 
+		let updated_gov_params: ClusterGovParams<u128, u64> = ClusterGovParams {
+			treasury_share: Perquintill::from_float(0.06),
+			validators_share: Perquintill::from_float(0.02),
+			cluster_reserve_share: Perquintill::from_float(0.03),
+			storage_bond_size: 1000,
+			storage_chill_delay: 500,
+			storage_unbonding_delay: 500,
+			unit_per_mb_stored: 100,
+			unit_per_mb_streamed: 100,
+			unit_per_put_request: 100,
+			unit_per_get_request: 100,
+		};
+
 		assert_ok!(DdcClusters::set_cluster_gov_params(
 			RuntimeOrigin::root(),
 			cluster_id,
-			cluster_gov_params
+			updated_gov_params.clone()
 		));
 
+		let updated_cluster_gov_params = DdcClusters::clusters_gov_params(cluster_id).unwrap();
+		assert_eq!(updated_cluster_gov_params.treasury_share, updated_gov_params.treasury_share);
+		assert_eq!(
+			updated_cluster_gov_params.validators_share,
+			updated_gov_params.validators_share
+		);
+		assert_eq!(
+			updated_cluster_gov_params.cluster_reserve_share,
+			updated_gov_params.cluster_reserve_share
+		);
+		assert_eq!(
+			updated_cluster_gov_params.storage_bond_size,
+			updated_gov_params.storage_bond_size
+		);
+		assert_eq!(
+			updated_cluster_gov_params.storage_chill_delay,
+			updated_gov_params.storage_chill_delay
+		);
+		assert_eq!(
+			updated_cluster_gov_params.storage_unbonding_delay,
+			updated_gov_params.storage_unbonding_delay
+		);
+		assert_eq!(
+			updated_cluster_gov_params.unit_per_mb_stored,
+			updated_gov_params.unit_per_mb_stored
+		);
+		assert_eq!(
+			updated_cluster_gov_params.unit_per_mb_streamed,
+			updated_gov_params.unit_per_mb_streamed
+		);
+		assert_eq!(
+			updated_cluster_gov_params.unit_per_put_request,
+			updated_gov_params.unit_per_put_request
+		);
+		assert_eq!(
+			updated_cluster_gov_params.unit_per_get_request,
+			updated_gov_params.unit_per_get_request
+		);
+
 		// Checking that event was emitted
 		assert_eq!(System::events().len(), 2);
 		System::assert_last_event(Event::ClusterGovParamsSet { cluster_id }.into())

pallets/ddc-nodes/src/benchmarking.rs

@@ -46,7 +46,9 @@ benchmarks! {
 			StorageNodePubKey::new([0; 32])).unwrap().props,
 			StorageNodeProps {
 				mode: StorageNodeMode::Storage,
-				host: vec![2u8, 255].try_into().unwrap(),
+				host: vec![3u8; 255].try_into().unwrap(),
+				domain: vec![4u8; 255].try_into().unwrap(),
+				ssl: true,
 				http_port: 45000u16,
 				grpc_port: 55000u16,
 				p2p_port: 65000u16,

pallets/ddc-nodes/src/lib.rs

@@ -77,6 +77,7 @@ pub mod pallet {
 		OnlyNodeProvider,
 		NodeIsAssignedToCluster,
 		HostLenExceedsLimit,
+		DomainLenExceedsLimit,
 		NodeHasDanglingStake,
 	}
 

pallets/ddc-nodes/src/node.rs

@@ -91,12 +91,14 @@ impl<T: frame_system::Config> NodeTrait<T> for Node<T> {
 #[derive(Debug, PartialEq)]
 pub enum NodeError {
 	StorageHostLenExceedsLimit,
+	StorageDomainLenExceedsLimit,
 }
 
 impl<T> From<NodeError> for Error<T> {
 	fn from(error: NodeError) -> Self {
 		match error {
 			NodeError::StorageHostLenExceedsLimit => Error::<T>::HostLenExceedsLimit,
+			NodeError::StorageDomainLenExceedsLimit => Error::<T>::DomainLenExceedsLimit,
 		}
 	}
 }

pallets/ddc-nodes/src/storage_node.rs

@@ -10,8 +10,8 @@ use serde::{Deserialize, Serialize};
 use sp_runtime::RuntimeDebug;
 
 parameter_types! {
-	pub MaxStorageNodeParamsLen: u16 = 2048;
 	pub MaxHostLen: u8 = 255;
+	pub MaxDomainLen: u8 = 255;
 }
 
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
@@ -28,6 +28,8 @@ pub struct StorageNode<T: frame_system::Config> {
 #[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo, PartialEq)]
 pub struct StorageNodeProps {
 	pub host: BoundedVec<u8, MaxHostLen>,
+	pub domain: BoundedVec<u8, MaxDomainLen>,
+	pub ssl: bool,
 	pub http_port: u16,
 	pub grpc_port: u16,
 	pub p2p_port: u16,
@@ -52,6 +54,11 @@ impl<T: frame_system::Config> StorageNode<T> {
 							Ok(vec) => vec,
 							Err(_) => return Err(NodeError::StorageHostLenExceedsLimit),
 						},
+						domain: match node_params.domain.try_into() {
+							Ok(vec) => vec,
+							Err(_) => return Err(NodeError::StorageDomainLenExceedsLimit),
+						},
+						ssl: node_params.ssl,
 						http_port: node_params.http_port,
 						grpc_port: node_params.grpc_port,
 						p2p_port: node_params.p2p_port,
@@ -81,10 +88,16 @@ impl<T: frame_system::Config> NodeTrait<T> for StorageNode<T> {
 	fn set_params(&mut self, node_params: NodeParams) -> Result<(), NodeError> {
 		match node_params {
 			NodeParams::StorageParams(storage_params) => {
+				self.props.mode = storage_params.mode;
 				self.props.host = match storage_params.host.try_into() {
 					Ok(vec) => vec,
 					Err(_) => return Err(NodeError::StorageHostLenExceedsLimit),
 				};
+				self.props.domain = match storage_params.domain.try_into() {
+					Ok(vec) => vec,
+					Err(_) => return Err(NodeError::StorageDomainLenExceedsLimit),
+				};
+				self.props.ssl = storage_params.ssl;
 				self.props.http_port = storage_params.http_port;
 				self.props.grpc_port = storage_params.grpc_port;
 				self.props.p2p_port = storage_params.p2p_port;

pallets/ddc-nodes/src/testing_utils.rs

@@ -16,15 +16,19 @@ pub fn create_user_and_config<T: Config>(
 	let node = NodePubKey::StoragePubKey(StorageNodePubKey::new([0; 32]));
 	let storage_node_params = NodeParams::StorageParams(StorageNodeParams {
 		mode: StorageNodeMode::Storage,
-		host: vec![1u8, 255],
+		host: vec![1u8; 255],
+		domain: vec![2u8; 255],
+		ssl: false,
 		http_port: 35000u16,
 		grpc_port: 25000u16,
 		p2p_port: 15000u16,
 	});
 
 	let new_storage_node_params = NodeParams::StorageParams(StorageNodeParams {
 		mode: StorageNodeMode::Storage,
-		host: vec![2u8, 255],
+		host: vec![3u8; 255],
+		domain: vec![4u8; 255],
+		ssl: true,
 		http_port: 45000u16,
 		grpc_port: 55000u16,
 		p2p_port: 65000u16,