fix: more lints (#783)

Author: rflechtner

pallets/pallet-bonded-coins/src/curves/mod.rs

@@ -65,7 +65,7 @@ where
 		match self {
 			Curve::Polynomial(params) => params,
 			Curve::SquareRoot(params) => params,
-			Curve::LMSR(params) => params,
+			Curve::Lmsr(params) => params,
 		}
 	}
 }

pallets/pallet-bonded-coins/src/lib.rs

@@ -46,6 +46,8 @@ pub mod pallet {
 	use sp_std::{
 		default::Default,
 		ops::{AddAssign, BitOrAssign, ShlAssign},
+		prelude::*,
+		vec::Vec,
 	};
 	use substrate_fixed::{
 		traits::{Fixed, FixedSigned, FixedUnsigned, ToFixed},
@@ -102,14 +104,17 @@ pub mod pallet {
 
 	pub(crate) const LOG_TARGET: &str = "runtime::pallet-bonded-coins";
 
-	/// Configure the pallet by specifying the parameters and types on which it depends.
+	/// Configure the pallet by specifying the parameters and types on which it
+	/// depends.
 	#[pallet::config]
 	pub trait Config: frame_system::Config {
-		/// Because this pallet emits events, it depends on the runtime's definition of an event.
+		/// Because this pallet emits events, it depends on the runtime's
+		/// definition of an event.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 		/// The currency used for storage deposits.
 		type DepositCurrency: MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;
-		/// A fungibles trait implementation to interact with currencies which can be used as collateral for minting bonded tokens.
+		/// A fungibles trait implementation to interact with currencies which
+		/// can be used as collateral for minting bonded tokens.
 		type CollateralCurrencies: MutateFungibles<Self::AccountId>
 			+ AccountTouch<CollateralAssetIdOf<Self>, Self::AccountId>
 			+ FungiblesMetadata<Self::AccountId>;
@@ -133,20 +138,23 @@ pub mod pallet {
 		#[pallet::constant]
 		type DepositPerCurrency: Get<DepositCurrencyBalanceOf<Self>>;
 
-		/// The base deposit required to create a new pool, primarily to cover the ED of the pool account.
+		/// The base deposit required to create a new pool, primarily to cover
+		/// the ED of the pool account.
 		#[pallet::constant]
 		type BaseDeposit: Get<DepositCurrencyBalanceOf<Self>>;
 
 		/// The origin for most permissionless and priviledged operations.
 		type DefaultOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
-		/// The dedicated origin for creating new bonded currency pools (typically permissionless).
+		/// The dedicated origin for creating new bonded currency pools
+		/// (typically permissionless).
 		type PoolCreateOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
 		/// The origin for permissioned operations (force_* transactions).
 		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 		/// The type used for pool ids
 		type PoolId: Parameter + MaxEncodedLen + From<[u8; 32]> + Into<Self::AccountId>;
 
-		/// The type used for asset ids. This is the type of the bonded currencies.
+		/// The type used for asset ids. This is the type of the bonded
+		/// currencies.
 		type AssetId: Parameter + Member + FullCodec + MaxEncodedLen + Saturating + One + Default;
 
 		type RuntimeHoldReason: From<HoldReason>;
@@ -194,11 +202,13 @@ pub mod pallet {
 		DestructionStarted {
 			id: T::PoolId,
 		},
-		/// Collateral distribution to bonded token holders has been completed for this pool - no more tokens or no more collateral to distribute.   
+		/// Collateral distribution to bonded token holders has been completed
+		/// for this pool (no more tokens or no more collateral to distribute).
 		RefundComplete {
 			id: T::PoolId,
 		},
-		/// A bonded token pool has been fully destroyed and all collateral and deposits have been refunded.
+		/// A bonded token pool has been fully destroyed and all collateral and
+		/// deposits have been refunded.
 		Destroyed {
 			id: T::PoolId,
 		},
@@ -215,17 +225,23 @@ pub mod pallet {
 		PoolUnknown,
 		/// The pool has no associated bonded currency with the given index.
 		IndexOutOfBounds,
-		/// The pool does not hold collateral to be refunded, or has no remaining supply of tokens to exchange. Call start_destroy to intiate teardown.
+		/// The pool does not hold collateral to be refunded, or has no
+		/// remaining supply of tokens to exchange. Call start_destroy to
+		/// intiate teardown.
 		NothingToRefund,
 		/// The user is not privileged to perform the requested operation.
 		NoPermission,
-		/// The pool is deactivated (i.e., in destroying or refunding state) and not available for use.
+		/// The pool is deactivated (i.e., in destroying or refunding state) and
+		/// not available for use.
 		PoolNotLive,
-		/// There are active accounts associated with this pool and thus it cannot be destroyed at this point.
+		/// There are active accounts associated with this pool and thus it
+		/// cannot be destroyed at this point.
 		LivePool,
 		/// This operation can only be made when the pool is in refunding state.
 		NotRefunding,
-		/// The number of currencies linked to a pool exceeds the limit parameter. Thrown by transactions that require specifying the number of a pool's currencies in order to determine weight limits upfront.
+		/// The number of currencies linked to a pool exceeds the limit
+		/// parameter. Thrown by transactions that require specifying the number
+		/// of a pool's currencies in order to determine weight limits upfront.
 		CurrencyCount,
 		InvalidInput,
 		Internal,
@@ -297,8 +313,8 @@ pub mod pallet {
 					Ok(())
 				})?;
 
-			// Touch the pool account in order to be able to transfer the collateral currency to it
-			// This should also verify that the currency actually exists
+			// Touch the pool account in order to be able to transfer the collateral
+			// currency to it. This should also verify that the currency actually exists.
 			T::CollateralCurrencies::touch(collateral_id.clone(), pool_account, &who)?;
 
 			Pools::<T>::set(
@@ -337,7 +353,7 @@ pub mod pallet {
 
 			let asset_id = pool_details
 				.bonded_currencies
-				.get(currency_idx as usize)
+				.get(currency_idx.saturated_into::<usize>())
 				.ok_or(Error::<T>::IndexOutOfBounds)?;
 
 			let pool_id_account = pool_id.into();
@@ -471,7 +487,8 @@ pub mod pallet {
 			// fail if cost > max_cost
 			ensure!(cost <= max_cost, Error::<T>::Slippage);
 
-			// Transfer the collateral. We do not want to kill the minter, so this operation can fail if the account is being reaped.
+			// Transfer the collateral. We do not want to kill the minter, so this operation
+			// can fail if the account is being reaped.
 			T::CollateralCurrencies::transfer(
 				pool_details.collateral_id,
 				&who,
@@ -625,9 +642,11 @@ pub mod pallet {
 
 			let pool_account = pool_id.clone().into();
 
-			// Choosing total_balance over reducible_balance to ensure that all funds are distributed fairly;
-			// in case of any locks present on the pool account, this could lead to refunds failing to execute though.
-			// This case would have to be resolved by governance, either by removing locks or force_destroying the pool.
+			// Choosing total_balance over reducible_balance to ensure that all funds are
+			// distributed fairly; in case of any locks present on the pool account, this
+			// could lead to refunds failing to execute. This case would have to be
+			// resolved by governance, either by removing locks or force_destroying the
+			// pool.
 			let total_collateral_issuance =
 				T::CollateralCurrencies::total_balance(pool_details.collateral_id.clone(), &pool_account);
 
@@ -640,7 +659,8 @@ pub mod pallet {
 			//  remove any existing locks on the account prior to burning
 			T::Fungibles::thaw(asset_id, &who).map_err(|freeze_error| freeze_error.into())?;
 
-			// With amount = max_value(), this trait implementation burns the reducible balance on the account and returns the actual amount burnt
+			// With amount = max_value(), this trait implementation burns the reducible
+			// balance on the account and returns the actual amount burnt
 			let burnt = T::Fungibles::burn_from(
 				asset_id.clone(),
 				&who,
@@ -665,7 +685,8 @@ pub mod pallet {
 				.checked_mul(&total_collateral_issuance)
 				.ok_or(ArithmeticError::Overflow)? // TODO: do we need a fallback if this fails?
 				.checked_div(&sum_of_issuances)
-				.ok_or(Error::<T>::NothingToRefund)?; // should be impossible - how would we be able to burn funds if the sum of total supplies is 0?
+				.ok_or(Error::<T>::NothingToRefund)?; // should be impossible - how would we be able to burn funds if the sum of total
+									  // supplies is 0?
 
 			if amount.is_zero()
 				|| T::CollateralCurrencies::can_deposit(
@@ -677,8 +698,9 @@ pub mod pallet {
 				.into_result()
 				.is_err()
 			{
-				// funds are burnt but the collateral received is not sufficient to be deposited to the account
-				// this is tolerated as otherwise we could have edge cases where it's impossible to refund at least some accounts
+				// Funds are burnt but the collateral received is not sufficient to be deposited
+				// to the account. This is tolerated as otherwise we could have edge cases where
+				// it's impossible to refund at least some accounts.
 				return Ok(());
 			}
 
@@ -690,7 +712,8 @@ pub mod pallet {
 				Preservation::Expendable,
 			)?; // TODO: check edge cases around existential deposit
 
-			// if collateral or total supply drops to zero, refunding is complete -> emit event
+			// if collateral or total supply drops to zero, refunding is complete
+			// -> emit event
 			if sum_of_issuances <= burnt || total_collateral_issuance <= transferred {
 				Self::deposit_event(Event::RefundComplete { id: pool_id });
 			}
@@ -733,7 +756,8 @@ pub mod pallet {
 
 			for asset_id in pool_details.bonded_currencies {
 				if T::Fungibles::asset_exists(asset_id.clone()) {
-					// This would fail with an LiveAsset error if there are any accounts left on any currency
+					// This would fail with an LiveAsset error if there are any accounts left on any
+					// currency
 					T::Fungibles::finish_destroy(asset_id)?;
 				}
 			}
@@ -892,7 +916,8 @@ pub mod pallet {
 					let has_holders = pool_details.bonded_currencies.iter().any(|asset_id| {
 						T::Fungibles::total_issuance(asset_id.clone()) > FungiblesBalanceOf::<T>::zero()
 					});
-					// destruction is only allowed when there are no holders or no collateral to distribute
+					// destruction is only allowed when there are no holders or no collateral to
+					// distribute
 					ensure!(!has_holders, Error::<T>::LivePool);
 				}
 			}
@@ -905,11 +930,13 @@ pub mod pallet {
 			new_pool_details.state.start_destroy();
 			Pools::<T>::set(&pool_id, Some(new_pool_details));
 
-			// emit this event before the destruction started events are emitted by assets deactivation
+			// emit this event before the destruction started events are emitted by assets
+			// deactivation
 			Self::deposit_event(Event::DestructionStarted { id: pool_id });
 
 			for asset_id in bonded_currencies {
-				// Governance or other pallets using the fungibles trait can in theory destroy an asset without this pallet knowing, so we check if it's still around
+				// Governance or other pallets using the fungibles trait can in theory destroy
+				// an asset without this pallet knowing, so we check if it's still around
 				if T::Fungibles::asset_exists(asset_id.clone()) {
 					T::Fungibles::start_destroy(asset_id, None)?;
 				}
@@ -935,7 +962,8 @@ pub mod pallet {
 		}
 
 		fn get_currencies_number(pool_details: &PoolDetailsOf<T>) -> u32 {
-			// bonded_currencies is a BoundedVec with maximum length MaxCurrencies, which is a u32; conversion to u32 must thus be lossless.
+			// bonded_currencies is a BoundedVec with maximum length MaxCurrencies, which is
+			// a u32; conversion to u32 must thus be lossless.
 			pool_details.bonded_currencies.len().saturated_into()
 		}
 

pallets/pallet-bonded-coins/src/tests/curves/lmsr.rs

@@ -17,9 +17,15 @@ fn mint_first_coin() {
 
 	let passive_issuance = Float::from_num(0);
 
-	// Costs for existing supply:  100000000 * ln(e^(0/100000000) + e^(0/100000000)) = 69314718.055994530942
-	// Costs for new supply: 100000000 * ln(e^(1/100000000) + e^(0/100000000)) = 69314718.555994532192
-	// Costs to mint the first coin: 69314718.555994532192 - 69314718.055994530942 = 0.50000000124972321215 -> 0.50000000124972321215
+	// Costs for existing supply:
+	// 100000000 * ln(e^(0/100000000) + e^(0/100000000)) = 69314718.055994530942
+
+	// Costs for new supply:
+	// 100000000 * ln(e^(1/100000000) + e^(0/100000000)) = 69314718.555994532192
+
+	// Costs to mint the first coin:
+	// 69314718.555994532192 - 69314718.055994530942 = 0.50000000124972321215 ->
+	// 0.50000000124972321215
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("0.50000000124972321215").unwrap();
@@ -39,9 +45,16 @@ fn high_supply_with_no_passive_issuance() {
 
 	let passive_issuance = Float::from_num(0);
 
-	// Costs for existing supply:  100000000 * ln(e^(100000000/100000000) + e^(0/100000000)) = 131326168.7518222834
-	// Costs for new supply: 100000000 * ln(e^(100000100/100000000) + e^(0/100000000)) = 131326241.857689977
-	// Costs to mint the first coin: 131326241.857689977 - 131326168.7518222834 = 73.1058676936
+	// Costs for existing supply:
+	// 100000000 * ln(e^(100000000/100000000) + e^(0/100000000)) =
+	// 131326168.7518222834
+
+	// Costs for new supply:
+	// 100000000 * ln(e^(100000100/100000000) + e^(0/100000000)) =
+	// 131326241.857689977
+
+	// Costs to mint the first coin:
+	// 131326241.857689977 - 131326168.7518222834 = 73.1058676936
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("73.1058676936").unwrap();
@@ -51,7 +64,8 @@ fn high_supply_with_no_passive_issuance() {
 
 #[test]
 fn high_supply_with_passive_issuance() {
-	// Create curve with liquidity parameter b=100_000_000, and passive issuance=1_000_000_000
+	// Create curve with liquidity parameter b=100_000_000, and passive
+	// issuance=1_000_000_000
 	let m = Float::from_num(100_000_000);
 	let curve = LMSRParameters { m };
 
@@ -61,17 +75,26 @@ fn high_supply_with_passive_issuance() {
 
 	let passive_issuance = Float::from_num(1_000_000_000);
 
-	// Costs for existing supply:  100000000 * ln(e^(100000000/100000000) + e^(1000000000/100000000)) = 1000012340.2189723259
-	// Costs for new supply: 100000000 * ln(e^(100000100/100000000) + e^(1000000000/100000000)) = 1000012340.2313117896
-	// Costs to mint the first coin: 1000012340.2313117896 - 1000012340.2189723259 = 0.0123394637
+	// Costs for existing supply:
+	// 100000000 * ln(e^(100000000/100000000) + e^(1000000000/100000000)) =
+	// 1000012340.2189723259
+
+	// Costs for new supply:
+	// 100000000 * ln(e^(100000100/100000000) + e^(1000000000/100000000)) =
+	// 1000012340.2313117896
+
+	// Costs to mint the first coin:
+	// 1000012340.2313117896 - 1000012340.2189723259 = 0.0123394637
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("0.0123394637").unwrap();
 
 	assert_relative_eq(costs, expected_costs, Float::from_str("0.0000001").unwrap());
 }
 
-// The main consequences of the low liquidity parameter is a lack of representable coins. e^40 goes beyond the representable range of the [Float] type.
+// The main consequences of the low liquidity parameter is a lack of
+// representable coins. e^40 goes beyond the representable range of the [Float]
+// type.
 #[test]
 fn low_liquidity_parameter() {
 	// Create curve with liquidity parameter b=100, and passive issuance=0
@@ -84,9 +107,14 @@ fn low_liquidity_parameter() {
 
 	let passive_issuance = Float::from_num(0);
 
-	// Costs for existing supply:  100 * ln(e^(1000/100) + e^(0/100)) = 1000.0045398899216865
-	// Costs for new supply: 100 * ln(e^(1100/100) + e^(0/100)) = 1100.0016701561318394
-	// Costs to mint the first coin: 1100.0016701561318394 - 1000.0045398899216865 = 99.9971302662101529
+	// Costs for existing supply:
+	// 100 * ln(e^(1000/100) + e^(0/100)) = 1000.0045398899216865
+
+	// Costs for new supply:
+	// 100 * ln(e^(1100/100) + e^(0/100)) = 1100.0016701561318394
+
+	// Costs to mint the first coin:
+	// 1100.0016701561318394 - 1000.0045398899216865 = 99.9971302662101529
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("99.9971302662101529").unwrap();
@@ -107,9 +135,17 @@ fn mint_coin_with_existing_supply_and_no_passive_issuance() {
 
 	let passive_issuance = Float::from_num(0);
 
-	// Costs for existing supply:  100000000 * ln(e^(100/100000000) + e^(0/100000000)) = 69314768.056007030941723211624
-	// Costs for new supply: 100000000 * ln(e^(101/100000000) + e^(0/100000000)) = 69314768.55600728219172321160383640
-	// Costs to mint the first coin: 69314768.55600728219172321160383640 - 69314768.55600728219172321160383640 = 0.5000002412499999999798364
+	// Costs for existing supply:
+	// 100000000 * ln(e^(100/100000000) + e^(0/100000000)) =
+	// 69314768.056007030941723211624
+
+	// Costs for new supply:
+	// 100000000 * ln(e^(101/100000000) + e^(0/100000000)) =
+	// 69314768.55600728219172321160383640
+
+	//Costs to mint the first coin:
+	// 69314768.55600728219172321160383640 - 69314768.55600728219172321160383640 =
+	// 0.5000002412499999999798364
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("0.50000024125").unwrap();
@@ -130,9 +166,14 @@ fn mint_coin_with_existing_supply_and_passive_issuance() {
 
 	let passive_issuance = Float::from_num(100);
 
-	// Costs for existing supply:  100000000 * ln(e^(100/100000000) + e^(100/100000000)) = 69314818.055994530942
-	// Costs for new supply: 100000000 * ln(e^(101/100000000) + e^(100/100000000)) = 69314818.555994532192
-	// Costs to mint the first coin: 69314818.555994532192 - 69314818.055994530942 = 0.50000000125
+	// Costs for existing supply:
+	// 100000000 * ln(e^(100/100000000) + e^(100/100000000)) = 69314818.055994530942
+
+	// Costs for new supply:
+	// 100000000 * ln(e^(101/100000000) + e^(100/100000000)) = 69314818.555994532192
+
+	// Costs to mint the first coin:
+	// 69314818.555994532192 - 69314818.055994530942 = 0.50000000125
 	let costs = curve.calculate_costs(low, high, vec![passive_issuance]).unwrap();
 
 	let expected_costs = Float::from_str("0.50000000125").unwrap();