Fix: [Referenda Tracks] Resolve representation issues that are breaking PJS apps (paritytech#7671)

This Pull Request fixes the following issues present with PJS derived
from paritytech#2072

- Represents `Tracks` constant as a `Vec<(TrackId, TrackInfo)>` instead
of `Vec<Track>`, so tracks iteration in PJS apps _Governance_ hook
remains as how it was before, and

![Screenshot 2025-02-22 at 12 31
28 pm](https://github.com/user-attachments/assets/a075b0b2-8984-43cc-9e72-99996de0ae1b)

- Encapsulates `[u8; N]` from `name` field in a `StringLike` structure
that represents its `TypeInfo` as a `&str` and encodes as such. This
fixes errors present in PJS apps that treat `name` as a javascript
`string`.

![Screenshot 2025-02-22 at 12 31
18 pm](https://github.com/user-attachments/assets/361a4f10-47b7-496d-9591-bc37afcf5ee1)

---------

Co-authored-by: Guillaume Thiolliere <[email protected]>
Co-authored-by: Oliver Tale-Yazdi <[email protected]>

Author: 3 people

prdoc/pr_7671.prdoc

@@ -0,0 +1,24 @@
+title: 'Fix: [Referenda Tracks] Resolve representation issues that are breaking PJS apps'
+
+doc:
+- audience: Runtime Dev
+  description: |-
+    The PR #2072 introduces a change in the representation of the `name` field, from a `&str` to a `[u8; N]` array. This is because 
+    tracks can be retrieves from storage, and thus, a static string representation doesn't meet with the storage traits requirements.
+
+    This PR encapsulates this array into a `StringLike` structure that allows representing the value as a `str` for SCALE and metadata
+    purposes. This is to avoid breaking changes.
+
+    This PR also reverts the representation of the `Tracks` constant as a tuple of `(TrackId, TrackInfo)` to accomplish the same
+    purpose of avoid breaking changes to runtime users and clients.
+crates:
+- name: pallet-referenda
+  bump: minor
+- name: collectives-westend-runtime
+  bump: minor
+- name: kitchensink-runtime
+  bump: minor
+- name: rococo-runtime
+  bump: minor
+- name: westend-runtime
+  bump: minor

substrate/frame/referenda/src/lib.rs

@@ -98,10 +98,10 @@ use self::branch::{BeginDecidingBranch, OneFewerDecidingBranch, ServiceBranch};
 pub use self::{
 	pallet::*,
 	types::{
-		BalanceOf, BoundedCallOf, CallOf, Curve, DecidingStatus, DecidingStatusOf, Deposit,
-		InsertSorted, NegativeImbalanceOf, PalletsOriginOf, ReferendumIndex, ReferendumInfo,
-		ReferendumInfoOf, ReferendumStatus, ReferendumStatusOf, ScheduleAddressOf, TallyOf, Track,
-		TrackIdOf, TrackInfo, TrackInfoOf, TracksInfo, VotesOf,
+		BalanceOf, BoundedCallOf, CallOf, ConstTrackInfo, Curve, DecidingStatus, DecidingStatusOf,
+		Deposit, InsertSorted, NegativeImbalanceOf, PalletsOriginOf, ReferendumIndex,
+		ReferendumInfo, ReferendumInfoOf, ReferendumStatus, ReferendumStatusOf, ScheduleAddressOf,
+		StringLike, TallyOf, Track, TrackIdOf, TrackInfo, TrackInfoOf, TracksInfo, VotesOf,
 	},
 	weights::WeightInfo,
 };
@@ -216,9 +216,30 @@ pub mod pallet {
 
 	#[pallet::extra_constants]
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// A list of tracks.
+		///
+		/// Note: if the tracks are dynamic, the value in the static metadata might be inaccurate.
 		#[pallet::constant_name(Tracks)]
-		fn tracks() -> Vec<Track<TrackIdOf<T, I>, BalanceOf<T, I>, BlockNumberFor<T>>> {
-			T::Tracks::tracks().map(|t| t.into_owned()).collect()
+		fn tracks() -> Vec<(TrackIdOf<T, I>, ConstTrackInfo<BalanceOf<T, I>, BlockNumberFor<T>>)> {
+			T::Tracks::tracks()
+				.map(|t| t.into_owned())
+				.map(|Track { id, info }| {
+					(
+						id,
+						ConstTrackInfo {
+							name: StringLike(info.name),
+							max_deciding: info.max_deciding,
+							decision_deposit: info.decision_deposit,
+							prepare_period: info.prepare_period,
+							decision_period: info.decision_period,
+							confirm_period: info.confirm_period,
+							min_enactment_period: info.min_enactment_period,
+							min_approval: info.min_approval,
+							min_support: info.min_support,
+						},
+					)
+				})
+				.collect()
 		}
 	}
 

substrate/frame/referenda/src/types.rs

@@ -19,13 +19,13 @@
 
 use super::*;
 use alloc::borrow::Cow;
-use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
+use codec::{Compact, Decode, Encode, EncodeLike, Input, MaxEncodedLen};
 use core::fmt::Debug;
 use frame_support::{
 	traits::{schedule::v3::Anon, Bounded},
 	Parameter,
 };
-use scale_info::TypeInfo;
+use scale_info::{Type, TypeInfo};
 use sp_arithmetic::{Rounding::*, SignedRounding::*};
 use sp_runtime::{FixedI64, PerThing, RuntimeDebug};
 
@@ -114,11 +114,59 @@ pub struct Deposit<AccountId, Balance> {
 
 pub const DEFAULT_MAX_TRACK_NAME_LEN: usize = 25;
 
+/// Helper structure to treat a `[u8; N]` array as a string.
+///
+/// This is a temporary fix (see [#7671](https://github.com/paritytech/polkadot-sdk/pull/7671)) in
+/// order to stop `polkadot.js` apps to fail when trying to decode the `name` field in `TrackInfo`.
+#[derive(Clone, Eq, Decode, PartialEq, Debug)]
+pub struct StringLike<const N: usize>(pub [u8; N]);
+
+impl<const N: usize> TypeInfo for StringLike<N> {
+	type Identity = <&'static str as TypeInfo>::Identity;
+
+	fn type_info() -> Type {
+		<&str as TypeInfo>::type_info()
+	}
+}
+
+impl<const N: usize> MaxEncodedLen for StringLike<N> {
+	fn max_encoded_len() -> usize {
+		<Compact<u32> as MaxEncodedLen>::max_encoded_len().saturating_add(N)
+	}
+}
+
+impl<const N: usize> Encode for StringLike<N> {
+	fn encode(&self) -> Vec<u8> {
+		use codec::Compact;
+		(Compact(N as u32), self.0).encode()
+	}
+}
+
+impl<const N: usize> Decode for StringLike<N> {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let Compact(size): Compact<u32> = Decode::decode(input)?;
+		if size != N as u32 {
+			return Err("Invalid size".into());
+		}
+
+		let bytes: [u8; N] = Decode::decode(input)?;
+		Ok(Self(bytes))
+	}
+}
+
+/// Detailed information about the configuration of a referenda track. Used for internal storage.
+pub type TrackInfo<Balance, Moment, const N: usize = DEFAULT_MAX_TRACK_NAME_LEN> =
+	TrackDetails<Balance, Moment, [u8; N]>;
+
+/// Detailed information about the configuration of a referenda track. Used for const querying.
+pub type ConstTrackInfo<Balance, Moment, const N: usize = DEFAULT_MAX_TRACK_NAME_LEN> =
+	TrackDetails<Balance, Moment, StringLike<N>>;
+
 /// Detailed information about the configuration of a referenda track
 #[derive(Clone, Encode, Decode, MaxEncodedLen, TypeInfo, Eq, PartialEq, Debug)]
-pub struct TrackInfo<Balance, Moment, const N: usize = DEFAULT_MAX_TRACK_NAME_LEN> {
+pub struct TrackDetails<Balance, Moment, Name> {
 	/// Name of this track.
-	pub name: [u8; N],
+	pub name: Name,
 	/// A limit for the number of referenda on this track that can be being decided at once.
 	/// For Root origin this should generally be just one.
 	pub max_deciding: u32,
@@ -287,7 +335,8 @@ impl<
 		Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
 		AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
 		ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
-	> ReferendumInfo<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>
+	>
+	ReferendumInfo<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>
 {
 	/// Take the Decision Deposit from `self`, if there is one. Returns an `Err` if `self` is not
 	/// in a valid state for the Decision Deposit to be refunded.
@@ -786,4 +835,20 @@ mod tests {
 			Err("The tracks that were returned by `tracks` were not sorted by `Id`")
 		);
 	}
+
+	#[test]
+	fn encoding_and_decoding_of_string_like_structure_works() {
+		let string_like = StringLike::<13>(*b"hello, world!");
+		let encoded: Vec<u8> = string_like.encode();
+
+		let decoded_as_vec: Vec<u8> =
+			Decode::decode(&mut &encoded.clone()[..]).expect("decoding as Vec<u8> should work");
+		assert_eq!(decoded_as_vec.len(), 13);
+		let decoded_as_str: alloc::string::String =
+			Decode::decode(&mut &encoded.clone()[..]).expect("decoding as str should work");
+		assert_eq!(decoded_as_str.len(), 13);
+		let decoded_as_string_like: StringLike<13> =
+			Decode::decode(&mut &encoded.clone()[..]).expect("decoding as StringLike should work");
+		assert_eq!(decoded_as_string_like.0.len(), 13);
+	}
 }