Feature/plmc 473 change edit metadata extrinsic to edit the whole metadata

pallets/funding/src/benchmarking.rs

@@ -458,24 +458,98 @@ mod benchmarks {
 		inst.advance_time(1u32.into()).unwrap();
 
 		let issuer = account::<AccountIdOf<T>>("issuer", 0, 0);
+		let issuer_funding = account::<AccountIdOf<T>>("issuer_funding", 0, 0);
 		whitelist_account!(issuer);
 
 		let project_metadata = default_project::<T>(inst.get_new_nonce(), issuer.clone());
 		let project_id = inst.create_new_project(project_metadata.clone(), issuer.clone());
-		let original_metadata_hash = project_metadata.offchain_information_hash.unwrap();
-		let edited_metadata_hash: H256 = hashed(EDITED_METADATA);
+
+		let project_metadata = ProjectMetadataOf::<T> {
+			token_information: CurrencyMetadata {
+				name: BoundedVec::try_from("Contribution Token TEST v2".as_bytes().to_vec()).unwrap(),
+				symbol: BoundedVec::try_from("CTESTv2".as_bytes().to_vec()).unwrap(),
+				decimals: ASSET_DECIMALS + 2,
+			},
+			mainnet_token_max_supply: BalanceOf::<T>::try_from(100_000_000_000_0_000_000_000u128)
+				.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+			total_allocation_size: BalanceOf::<T>::try_from(200_000_000_0_000_000_000u128)
+				.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+			auction_round_allocation_percentage: Percent::from_percent(30u8),
+			minimum_price: 11u128.into(),
+			bidding_ticket_sizes: BiddingTicketSizes {
+				professional: TicketSize::new(
+					Some(
+						BalanceOf::<T>::try_from(5000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+					Some(
+						BalanceOf::<T>::try_from(10_000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+				),
+				institutional: TicketSize::new(
+					Some(
+						BalanceOf::<T>::try_from(5000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+					Some(
+						BalanceOf::<T>::try_from(10_000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+				),
+				phantom: Default::default(),
+			},
+			contributing_ticket_sizes: ContributingTicketSizes {
+				retail: TicketSize::new(
+					Some(
+						BalanceOf::<T>::try_from(5000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+					Some(
+						BalanceOf::<T>::try_from(10_000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+				),
+				professional: TicketSize::new(
+					Some(
+						BalanceOf::<T>::try_from(5000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+					Some(
+						BalanceOf::<T>::try_from(10_000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+				),
+				institutional: TicketSize::new(
+					Some(
+						BalanceOf::<T>::try_from(5000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+					Some(
+						BalanceOf::<T>::try_from(10_000 * US_DOLLAR)
+							.unwrap_or_else(|_| panic!("Failed to create BalanceOf")),
+					),
+				),
+				phantom: Default::default(),
+			},
+			participation_currencies: vec![AcceptedFundingAsset::USDT, AcceptedFundingAsset::USDC].try_into().unwrap(),
+			funding_destination_account: issuer_funding.clone().clone(),
+			offchain_information_hash: Some(hashed(format!("{}-{}", METADATA, 69)).into()),
+		};
+
 		let jwt = get_mock_jwt(issuer.clone(), InvestorType::Institutional, generate_did_from_account(issuer.clone()));
+
 		#[extrinsic_call]
-		edit_metadata(RawOrigin::Signed(issuer), jwt, project_id, edited_metadata_hash.into());
+		edit_metadata(RawOrigin::Signed(issuer), jwt, project_id, project_metadata.clone());
 
 		// * validity checks *
 		// Storage
 		let stored_metadata = ProjectsMetadata::<T>::get(project_id).unwrap();
-		assert_eq!(stored_metadata.offchain_information_hash, Some(edited_metadata_hash.into()));
-		assert!(original_metadata_hash != edited_metadata_hash.into());
+
+		assert_eq!(stored_metadata, project_metadata);
 
 		// Events
-		frame_system::Pallet::<T>::assert_last_event(Event::<T>::MetadataEdited { project_id }.into());
+		frame_system::Pallet::<T>::assert_last_event(Event::<T>::MetadataEdited { project_id, metadata: project_metadata }.into());
 	}
 
 	#[benchmark]
@@ -2218,9 +2292,10 @@ mod benchmarks {
 		let insertion_block_number: BlockNumberFor<T> = current_block + One::one();
 
 		fill_projects_to_update::<T>(x, insertion_block_number);
+		let jwt = get_mock_jwt(issuer.clone(), InvestorType::Institutional, generate_did_from_account(issuer.clone()));
 
 		#[extrinsic_call]
-		decide_project_outcome(RawOrigin::Signed(issuer), project_id, FundingOutcomeDecision::AcceptFunding);
+		decide_project_outcome(RawOrigin::Signed(issuer), jwt, project_id, FundingOutcomeDecision::AcceptFunding);
 
 		// * validity checks *
 		// Storage

pallets/funding/src/functions.rs

@@ -794,46 +794,23 @@ impl<T: Config> Pallet<T> {
 
 // Extrinsics and HRMP interactions
 impl<T: Config> Pallet<T> {
-	/// Called by user extrinsic
-	/// Creates a project and assigns it to the `issuer` account.
-	///
-	/// # Arguments
-	/// * `issuer` - The account that will be the issuer of the project.
-	/// * `project` - The project struct containing all the necessary information.
-	///
-	/// # Storage access
-	/// * [`ProjectsMetadata`] - Inserting the main project information. 1 to 1 with the `project` argument.
-	/// * [`ProjectsDetails`] - Inserting the project information. constructed from the `project` argument.
-	/// * [`NextProjectId`] - Getting the next usable id, and updating it for the next project.
-	///
-	/// # Success path
-	/// The `project` argument is valid. A ProjectInfo struct is constructed, and the storage is updated
-	/// with the new structs and mappings to reflect the new project creation
-	///
-	/// # Next step
-	/// The issuer will call an extrinsic to start the evaluation round of the project.
-	/// [`do_start_evaluation`](Self::do_start_evaluation) will be executed.
-	#[transactional]
-	pub fn do_create(issuer: &AccountIdOf<T>, initial_metadata: ProjectMetadataOf<T>, did: Did) -> DispatchResult {
-		// * Get variables *
-		let project_id = NextProjectId::<T>::get();
-		let maybe_active_project = DidWithActiveProjects::<T>::get(did.clone());
-
-		// * Validity checks *
-		ensure!(maybe_active_project == None, Error::<T>::IssuerHasActiveProjectAlready);
-
-		if let Err(error) = initial_metadata.is_valid() {
+	fn project_validation(
+		metadata: &ProjectMetadataOf<T>,
+		issuer: AccountIdOf<T>,
+		did: Did,
+	) -> Result<(ProjectDetailsOf<T>, BucketOf<T>), DispatchError> {
+		if let Err(error) = metadata.is_valid() {
 			return match error {
 				ValidityError::PriceTooLow => Err(Error::<T>::PriceTooLow.into()),
 				ValidityError::TicketSizeError => Err(Error::<T>::TicketSizeError.into()),
 				ValidityError::ParticipationCurrenciesError => Err(Error::<T>::ParticipationCurrenciesError.into()),
 			};
 		}
-		let total_allocation_size = initial_metadata.total_allocation_size;
+		let total_allocation_size = metadata.total_allocation_size;
 
 		// * Calculate new variables *
 		let fundraising_target =
-			initial_metadata.minimum_price.checked_mul_int(total_allocation_size).ok_or(Error::<T>::BadMath)?;
+			metadata.minimum_price.checked_mul_int(total_allocation_size).ok_or(Error::<T>::BadMath)?;
 		let now = <frame_system::Pallet<T>>::block_number();
 		let project_details = ProjectDetails {
 			issuer_account: issuer.clone(),
@@ -843,7 +820,7 @@ impl<T: Config> Pallet<T> {
 			fundraising_target,
 			status: ProjectStatus::Application,
 			phase_transition_points: PhaseTransitionPoints::new(now),
-			remaining_contribution_tokens: initial_metadata.total_allocation_size,
+			remaining_contribution_tokens: metadata.total_allocation_size,
 			funding_amount_reached: BalanceOf::<T>::zero(),
 			cleanup: Cleaner::NotReady,
 			evaluation_round_info: EvaluationRoundInfoOf::<T> {
@@ -860,7 +837,40 @@ impl<T: Config> Pallet<T> {
 			},
 		};
 
-		let bucket: BucketOf<T> = Self::create_bucket_from_metadata(&initial_metadata)?;
+		let bucket: BucketOf<T> = Self::create_bucket_from_metadata(&metadata)?;
+
+		Ok((project_details, bucket))
+	}
+
+	/// Called by user extrinsic
+	/// Creates a project and assigns it to the `issuer` account.
+	///
+	/// # Arguments
+	/// * `issuer` - The account that will be the issuer of the project.
+	/// * `project` - The project struct containing all the necessary information.
+	///
+	/// # Storage access
+	/// * [`ProjectsMetadata`] - Inserting the main project information. 1 to 1 with the `project` argument.
+	/// * [`ProjectsDetails`] - Inserting the project information. constructed from the `project` argument.
+	/// * [`NextProjectId`] - Getting the next usable id, and updating it for the next project.
+	///
+	/// # Success path
+	/// The `project` argument is valid. A ProjectInfo struct is constructed, and the storage is updated
+	/// with the new structs and mappings to reflect the new project creation
+	///
+	/// # Next step
+	/// The issuer will call an extrinsic to start the evaluation round of the project.
+	/// [`do_start_evaluation`](Self::do_start_evaluation) will be executed.
+	#[transactional]
+	pub fn do_create(issuer: &AccountIdOf<T>, initial_metadata: ProjectMetadataOf<T>, did: Did) -> DispatchResult {
+		// * Get variables *
+		let project_id = NextProjectId::<T>::get();
+		let maybe_active_project = DidWithActiveProjects::<T>::get(did.clone());
+
+		// * Validity checks *
+		ensure!(maybe_active_project == None, Error::<T>::IssuerHasActiveProjectAlready);
+
+		let (project_details, bucket) = Self::project_validation(&initial_metadata, issuer.clone(), did.clone())?;
 
 		// Each project needs an escrow system account to temporarily hold the USDT/USDC. We need to create it by depositing `ED` amount of PLMC into it.
 		// This should be paid by the issuer.
@@ -891,7 +901,6 @@ impl<T: Config> Pallet<T> {
 	pub fn do_remove_project(issuer: &AccountIdOf<T>, project_id: ProjectId, did: Did) -> DispatchResult {
 		// * Get variables *
 		let project_details = ProjectsDetails::<T>::get(project_id).ok_or(Error::<T>::ProjectDetailsNotFound)?;
-		let project_metadata = ProjectsMetadata::<T>::get(project_id).ok_or(Error::<T>::ProjectNotFound)?;
 
 		// * Validity checks *
 		ensure!(&project_details.issuer_account == issuer, Error::<T>::NotAllowed);
@@ -917,31 +926,32 @@ impl<T: Config> Pallet<T> {
 	/// * `project_metadata_hash` - The hash of the image that contains the metadata
 	///
 	/// # Storage access
-	/// * [`Images`] - Check that the image exists
 	/// * [`ProjectsDetails`] - Check that the project is not frozen
 	/// * [`ProjectsMetadata`] - Update the metadata hash
 	#[transactional]
 	pub fn do_edit_metadata(
 		issuer: AccountIdOf<T>,
 		project_id: ProjectId,
-		project_metadata_hash: T::Hash,
+		new_project_metadata: ProjectMetadataOf<T>,
 	) -> DispatchResult {
 		// * Get variables *
-		let mut project_metadata = ProjectsMetadata::<T>::get(project_id).ok_or(Error::<T>::ProjectNotFound)?;
 		let project_details = ProjectsDetails::<T>::get(project_id).ok_or(Error::<T>::ProjectDetailsNotFound)?;
 
 		// * Validity checks *
 		ensure!(project_details.issuer_account == issuer, Error::<T>::NotAllowed);
 		ensure!(!project_details.is_frozen, Error::<T>::Frozen);
 
 		// * Calculate new variables *
+		let (project_details, bucket) =
+			Self::project_validation(&new_project_metadata, issuer.clone(), project_details.issuer_did.clone())?;
 
-		// * Update Storage *
-		project_metadata.offchain_information_hash = Some(project_metadata_hash);
-		ProjectsMetadata::<T>::insert(project_id, project_metadata);
+		// * Update storage *
+		ProjectsMetadata::<T>::insert(project_id, new_project_metadata.clone());
+		ProjectsDetails::<T>::insert(project_id, project_details);
+		Buckets::<T>::insert(project_id, bucket);
 
 		// * Emit events *
-		Self::deposit_event(Event::MetadataEdited { project_id });
+		Self::deposit_event(Event::MetadataEdited { project_id, metadata: new_project_metadata });
 
 		Ok(())
 	}

pallets/funding/src/lib.rs

@@ -206,11 +206,10 @@ pub mod pallet {
 		traits::{OnFinalize, OnIdle, OnInitialize},
 	};
 	use frame_system::pallet_prelude::*;
-	use local_macros::*;
 	use sp_arithmetic::Percent;
 	use sp_runtime::{
 		traits::{Convert, ConvertBack, Get},
-		DispatchErrorWithPostInfo, TransactionOutcome,
+		DispatchErrorWithPostInfo,
 	};
 
 	#[cfg(any(feature = "runtime-benchmarks", feature = "std"))]
@@ -555,11 +554,6 @@ pub mod pallet {
 	pub type RetailParticipations<T: Config> =
 		StorageMap<_, Blake2_128Concat, Did, BoundedVec<ProjectId, MaxParticipationsForMaxMultiplier>, ValueQuery>;
 
-	#[pallet::storage]
-	// After 25 participations, the retail user has access to the max multiplier of 10x, so no need to keep tracking it
-	pub type RetailParticipations<T: Config> =
-		StorageMap<_, Blake2_128Concat, Did, BoundedVec<ProjectId, MaxParticipationsForMaxMultiplier>, ValueQuery>;
-
 	#[pallet::storage]
 	/// A map to keep track of what issuer's did has an active project. It prevents one issuer having multiple active projects
 	pub type DidWithActiveProjects<T: Config> = StorageMap<_, Blake2_128Concat, Did, ProjectId, OptionQuery>;
@@ -587,6 +581,7 @@ pub mod pallet {
 		/// The metadata of a project was modified.
 		MetadataEdited {
 			project_id: ProjectId,
+			metadata: ProjectMetadataOf<T>,
 		},
 		/// The evaluation phase of a project started.
 		EvaluationStarted {
@@ -991,6 +986,7 @@ pub mod pallet {
 		/// The issuer tried to create a new project but already has an active one
 		IssuerHasActiveProjectAlready,
 		NotEnoughFunds,
+		BadMetadata,
 	}
 
 	#[pallet::call]
@@ -1021,12 +1017,12 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			jwt: UntrustedToken,
 			project_id: ProjectId,
-			project_metadata_hash: T::Hash,
+			new_project_metadata: ProjectMetadataOf<T>,
 		) -> DispatchResult {
 			let (account, _did, investor_type) =
 				T::InvestorOrigin::ensure_origin(origin, &jwt, T::VerifierPublicKey::get())?;
 			ensure!(investor_type == InvestorType::Institutional, Error::<T>::NotAllowed);
-			Self::do_edit_metadata(account, project_id, project_metadata_hash)
+			Self::do_edit_metadata(account, project_id, new_project_metadata)
 		}
 
 		/// Starts the evaluation round of a project. It needs to be called by the project issuer.
@@ -1275,12 +1271,11 @@ pub mod pallet {
 			project_id: ProjectId,
 			outcome: FundingOutcomeDecision,
 		) -> DispatchResultWithPostInfo {
-			let caller = ensure_signed(origin)?;
-			let (account, did, investor_type) =
+			let (account, _did, investor_type) =
 				T::InvestorOrigin::ensure_origin(origin, &jwt, T::VerifierPublicKey::get())?;
 			ensure!(investor_type == InvestorType::Institutional, Error::<T>::NotAllowed);
 
-			Self::do_decide_project_outcome(caller, project_id, outcome)
+			Self::do_decide_project_outcome(account, project_id, outcome)
 		}
 
 		#[pallet::call_index(18)]
@@ -1503,7 +1498,7 @@ pub mod pallet {
 				} else {
 					*used_weight = used_weight.saturating_add(fallback_weight);
 				},
-			Err(DispatchErrorWithPostInfo::<PostDispatchInfo> { error, post_info }) => {
+			Err(DispatchErrorWithPostInfo::<PostDispatchInfo> { error: _error, post_info }) => {
 				if let Some(actual_weight) = post_info.actual_weight {
 					*used_weight = used_weight.saturating_add(actual_weight);
 				} else {
@@ -1719,6 +1714,7 @@ pub mod local_macros {
 
 	/// used to unwrap storage values that can be Err in places where an error cannot be returned,
 	/// but an event should be emitted, and skip to the next iteration of a loop
+	#[allow(unused_macros)]
 	macro_rules! unwrap_result_or_skip {
 		($option:expr, $project_id:expr, $error_handler:expr) => {
 			match $option {
@@ -1730,5 +1726,4 @@ pub mod local_macros {
 			}
 		};
 	}
-	pub(crate) use unwrap_result_or_skip;
 }