feat(pallet-api/fungibles): benchmark read functions

pallets/api/src/fungibles/benchmarking.rs

@@ -14,7 +14,10 @@ use frame_support::{
 use frame_system::RawOrigin;
 use sp_runtime::traits::Zero;
 
-use super::{AccountIdOf, AssetsInstanceOf, AssetsOf, BalanceOf, Call, Config, Pallet, TokenIdOf};
+use super::{
+	AccountIdOf, AssetsInstanceOf, AssetsOf, BalanceOf, Call, Config, Pallet, Read, TokenIdOf,
+};
+use crate::Read as _;
 
 const SEED: u32 = 1;
 
@@ -103,5 +106,73 @@ mod benchmarks {
 		Ok(())
 	}
 
+	#[benchmark]
+	// Storage: `Assets`
+	fn total_supply() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::TotalSupply(TokenIdOf::<T>::zero()));
+		}
+	}
+	#[benchmark]
+	// Storage: `AssetAccount`
+	fn balance_of() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::BalanceOf {
+				token: TokenIdOf::<T>::zero(),
+				owner: account("Alice", 0, SEED),
+			});
+		}
+	}
+	#[benchmark]
+	// Storage: `Approval`
+	fn allowance() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::Allowance {
+				token: TokenIdOf::<T>::zero(),
+				owner: account("Alice", 0, SEED),
+				spender: account("Bob", 0, SEED),
+			});
+		}
+	}
+
+	#[benchmark]
+	// Storage: `AssetMetadata`
+	fn token_name() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::TokenName(TokenIdOf::<T>::zero()));
+		}
+	}
+
+	#[benchmark]
+	// Storage: `AssetMetadata`
+	fn token_symbol() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::TokenSymbol(TokenIdOf::<T>::zero()));
+		}
+	}
+
+	#[benchmark]
+	// Storage: `AssetMetadata`
+	fn token_decimals() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::TokenDecimals(TokenIdOf::<T>::zero()));
+		}
+	}
+
+	#[benchmark]
+	// Storage: `Assets`
+	fn token_exists() {
+		#[block]
+		{
+			Pallet::<T>::read(Read::TokenExists(TokenIdOf::<T>::zero()));
+		}
+	}
+
 	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
 }

pallets/api/src/fungibles/mod.rs

@@ -490,9 +490,17 @@ pub mod pallet {
 		///
 		/// # Parameters
 		/// - `request` - The read request.
-		fn weight(_request: &Self::Read) -> Weight {
-			// TODO: match on request and return benchmarked weight
-			T::DbWeight::get().reads(1_u64)
+		fn weight(request: &Self::Read) -> Weight {
+			use Read::*;
+			match request {
+				TotalSupply(_) => <T as Config>::WeightInfo::total_supply(),
+				BalanceOf { .. } => <T as Config>::WeightInfo::balance_of(),
+				Allowance { .. } => <T as Config>::WeightInfo::allowance(),
+				TokenName(_) => <T as Config>::WeightInfo::token_name(),
+				TokenSymbol(_) => <T as Config>::WeightInfo::token_symbol(),
+				TokenDecimals(_) => <T as Config>::WeightInfo::token_decimals(),
+				TokenExists(_) => <T as Config>::WeightInfo::token_exists(),
+			}
 		}
 
 		/// Performs the requested read and returns the result.

pallets/api/src/fungibles/tests.rs

@@ -342,3 +342,100 @@ fn set_metadata_token(
 ) {
 	assert_ok!(Assets::set_metadata(signed(owner), token, name, symbol, decimals));
 }
+
+mod read_weights {
+	use frame_support::weights::Weight;
+
+	use super::*;
+	use crate::fungibles::{weights::WeightInfo, Config};
+
+	struct ReadWeightInfo {
+		total_supply: Weight,
+		balance_of: Weight,
+		allowance: Weight,
+		token_name: Weight,
+		token_symbol: Weight,
+		token_decimals: Weight,
+		token_exists: Weight,
+	}
+
+	impl ReadWeightInfo {
+		fn new() -> Self {
+			Self {
+				total_supply: Fungibles::weight(&TotalSupply(TOKEN)),
+				balance_of: Fungibles::weight(&BalanceOf { token: TOKEN, owner: ALICE }),
+				allowance: Fungibles::weight(&Allowance {
+					token: TOKEN,
+					owner: ALICE,
+					spender: BOB,
+				}),
+				token_name: Fungibles::weight(&TokenName(TOKEN)),
+				token_symbol: Fungibles::weight(&TokenSymbol(TOKEN)),
+				token_decimals: Fungibles::weight(&TokenDecimals(TOKEN)),
+				token_exists: Fungibles::weight(&TokenExists(TOKEN)),
+			}
+		}
+	}
+
+	#[test]
+	fn ensure_read_matches_benchmarks() {
+		let ReadWeightInfo {
+			allowance,
+			balance_of,
+			token_decimals,
+			token_name,
+			token_symbol,
+			total_supply,
+			token_exists,
+		} = ReadWeightInfo::new();
+
+		assert_eq!(total_supply, <Test as Config>::WeightInfo::total_supply());
+		assert_eq!(balance_of, <Test as Config>::WeightInfo::balance_of());
+		assert_eq!(allowance, <Test as Config>::WeightInfo::allowance());
+		assert_eq!(token_name, <Test as Config>::WeightInfo::token_name());
+		assert_eq!(token_symbol, <Test as Config>::WeightInfo::token_symbol());
+		assert_eq!(token_decimals, <Test as Config>::WeightInfo::token_decimals());
+		assert_eq!(token_exists, <Test as Config>::WeightInfo::token_exists());
+	}
+
+	// These types read from the `AssetMetadata` storage.
+	#[test]
+	fn ensure_asset_metadata_variants_match() {
+		let ReadWeightInfo { token_decimals, token_name, token_symbol, .. } = ReadWeightInfo::new();
+
+		assert_eq!(token_decimals, token_name);
+		assert_eq!(token_decimals, token_symbol);
+	}
+
+	// These types read from the `Assets` storage.
+	#[test]
+	fn ensure_asset_variants_match() {
+		let ReadWeightInfo { total_supply, token_exists, .. } = ReadWeightInfo::new();
+
+		assert_eq!(total_supply, token_exists);
+	}
+
+	// Proof size is based on `MaxEncodedLen`, not hardware.
+	// This test ensures that the data structure sizes do not change with upgrades.
+	#[test]
+	fn ensure_expected_proof_size_does_not_change() {
+		let ReadWeightInfo {
+			allowance,
+			balance_of,
+			token_decimals,
+			token_name,
+			token_symbol,
+			total_supply,
+			token_exists,
+		} = ReadWeightInfo::new();
+
+		// These values come from `weights.rs`.
+		assert_eq!(allowance.proof_size(), 3613);
+		assert_eq!(balance_of.proof_size(), 3599);
+		assert_eq!(token_name.proof_size(), 3605);
+		assert_eq!(token_symbol.proof_size(), 3605);
+		assert_eq!(token_decimals.proof_size(), 3605);
+		assert_eq!(total_supply.proof_size(), 3675);
+		assert_eq!(token_exists.proof_size(), 3675);
+	}
+}