pass asset id as ref for ConversionToAssetBalance

cumulus/parachains/common/src/xcm_config.rs

@@ -60,7 +60,7 @@ where
 		let amount = WeightToFee::weight_to_fee(&weight);
 		// If the amount gotten is not at least the ED, then make it be the ED of the asset
 		// This is to avoid burning assets and decreasing the supply
-		let asset_amount = BalanceConverter::to_asset_balance(amount, asset_id)
+		let asset_amount = BalanceConverter::to_asset_balance(amount, &asset_id)
 			.map_err(|_| XcmError::TooExpensive)?;
 		Ok(asset_amount)
 	}

substrate/frame/assets/src/tests.rs

@@ -1560,19 +1560,19 @@ fn balance_conversion_should_work() {
 		assert_ok!(Assets::force_create(RuntimeOrigin::root(), not_sufficient, 1, false, 10));
 		assert_eq!(asset_ids(), vec![23, 42, 999]);
 		assert_eq!(
-			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, 1234),
+			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, &1234),
 			Err(ConversionError::AssetMissing)
 		);
 		assert_eq!(
 			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(
 				100,
-				not_sufficient
+				&not_sufficient
 			),
 			Err(ConversionError::AssetNotSufficient)
 		);
 		// 10 / 1 == 10 -> the conversion should 10x the value
 		assert_eq!(
-			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, id),
+			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, &id),
 			Ok(100 * 10)
 		);
 	});

substrate/frame/assets/src/types.rs

@@ -303,7 +303,7 @@ where
 	/// balance is zero.
 	fn to_asset_balance(
 		balance: BalanceOf<F, T>,
-		asset_id: AssetIdOf<T, I>,
+		asset_id: &AssetIdOf<T, I>,
 	) -> Result<AssetBalanceOf<T, I>, ConversionError> {
 		let asset = Asset::<T, I>::get(asset_id).ok_or(ConversionError::AssetMissing)?;
 		// only sufficient assets have a min balance with reliable value

substrate/frame/support/src/traits/tokens/misc.rs

@@ -261,8 +261,10 @@ impl<
 /// Converts a balance value into an asset balance.
 pub trait ConversionToAssetBalance<InBalance, AssetId, AssetBalance> {
 	type Error;
-	fn to_asset_balance(balance: InBalance, asset_id: AssetId)
-		-> Result<AssetBalance, Self::Error>;
+	fn to_asset_balance(
+		balance: InBalance,
+		asset_id: &AssetId,
+	) -> Result<AssetBalance, Self::Error>;
 }
 
 /// Converts an asset balance value into balance.

substrate/frame/transaction-payment/asset-tx-payment/src/payment.rs

@@ -121,7 +121,7 @@ where
 		// less than one (e.g. 0.5) but gets rounded down by integer division we introduce a minimum
 		// fee.
 		let min_converted_fee = if fee.is_zero() { Zero::zero() } else { One::one() };
-		let converted_fee = CON::to_asset_balance(fee, asset_id)
+		let converted_fee = CON::to_asset_balance(fee, &asset_id)
 			.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))?
 			.max(min_converted_fee);
 		let can_withdraw =
@@ -156,10 +156,10 @@ where
 	) -> Result<(AssetBalanceOf<T>, AssetBalanceOf<T>), TransactionValidityError> {
 		let min_converted_fee = if corrected_fee.is_zero() { Zero::zero() } else { One::one() };
 		// Convert the corrected fee and tip into the asset used for payment.
-		let converted_fee = CON::to_asset_balance(corrected_fee, paid.asset())
+		let converted_fee = CON::to_asset_balance(corrected_fee, &paid.asset())
 			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })?
 			.max(min_converted_fee);
-		let converted_tip = CON::to_asset_balance(tip, paid.asset())
+		let converted_tip = CON::to_asset_balance(tip, &paid.asset())
 			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })?;
 
 		// Calculate how much refund we should return.