Comment + Cargo fmt

node/src/chain_spec/battery_station.rs

@@ -28,7 +28,7 @@ use zeitgeist_primitives::{
         ztg::{LIQUIDITY_MINING, LIQUIDITY_MINING_PTD},
         BASE,
     },
-    types::{Asset::ForeignAsset, AccountId}
+    types::{AccountId, Asset::ForeignAsset},
 };
 
 #[cfg(feature = "parachain")]
@@ -115,11 +115,11 @@ pub(super) fn get_wasm() -> Result<&'static [u8], String> {
 
 generate_generic_genesis_function!(
     battery_station_runtime,
-    asset_registry: battery_station_runtime::AssetRegistryConfig { 
-        assets: vec![], 
+    asset_registry: battery_station_runtime::AssetRegistryConfig {
+        assets: vec![],
         last_asset_id: ForeignAsset(0),
     },
-    sudo: battery_station_runtime::SudoConfig { 
+    sudo: battery_station_runtime::SudoConfig {
         key: Some(root_key_staging_battery_station()),
     },
 );

node/src/chain_spec/dev.rs

@@ -46,11 +46,11 @@ fn authority_keys_from_seed(
 
 generate_generic_genesis_function! {
     battery_station_runtime,
-    asset_registry: battery_station_runtime::AssetRegistryConfig { 
-        assets: vec![], 
+    asset_registry: battery_station_runtime::AssetRegistryConfig {
+        assets: vec![],
         last_asset_id: ForeignAsset(0),
     },
-    sudo: battery_station_runtime::SudoConfig { 
+    sudo: battery_station_runtime::SudoConfig {
         key: Some(get_account_id_from_seed::<sr25519::Public>("Alice")),
     },
 }

primitives/src/asset.rs

@@ -28,18 +28,29 @@ use scale_info::TypeInfo;
 #[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
 #[derive(
-    Clone, Copy, Debug, Decode, Default, Eq, Encode, MaxEncodedLen, Ord, PartialEq, PartialOrd, TypeInfo,
+    Clone,
+    Copy,
+    Debug,
+    Decode,
+    Default,
+    Eq,
+    Encode,
+    MaxEncodedLen,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    TypeInfo,
 )]
 pub enum Asset<MI: MaxEncodedLen> {
     CategoricalOutcome(MI, CategoryIndex),
     ScalarOutcome(MI, ScalarPosition),
     CombinatorialOutcome,
     PoolShare(SerdeWrapper<PoolId>),
-    #[default] Ztg,
+    #[default]
+    Ztg,
     ForeignAsset(u32),
 }
 
-
 /// In a scalar market, users can either choose a `Long` position,
 /// meaning that they think the outcome will be closer to the upper bound
 /// or a `Short` position meaning that they think the outcome will be closer

runtime/battery-station/src/lib.rs

@@ -56,7 +56,10 @@ use {
     frame_support::traits::{AsEnsureOriginWithArg, Everything, Nothing},
     frame_system::EnsureSigned,
     xcm_builder::{EnsureXcmOrigin, FixedWeightBounds, LocationInverter},
-    xcm_config::{asset_registry::{CustomAssetProcessor, CustomMetadata}, config::{LocalOriginToLocation, XcmConfig, XcmOriginToTransactDispatchOrigin, XcmRouter}},
+    xcm_config::{
+        asset_registry::{CustomAssetProcessor, CustomMetadata},
+        config::{LocalOriginToLocation, XcmConfig, XcmOriginToTransactDispatchOrigin, XcmRouter},
+    },
 };
 
 use frame_support::construct_runtime;
@@ -142,21 +145,20 @@ create_runtime_with_additional_pallets!(
     UnknownTokens: orml_unknown_tokens::{Pallet, Storage, Event} = 152,
 );
 
-
 impl pallet_sudo::Config for Runtime {
     type Call = Call;
     type Event = Event;
 }
 
 #[cfg(feature = "parachain")]
 impl orml_asset_registry::Config for Runtime {
-	type AssetId = CurrencyId;
-	type AssetProcessor = CustomAssetProcessor;
-	type AuthorityOrigin = AsEnsureOriginWithArg<EnsureRootOrTwoThirdsCouncil>;
-	type Balance = Balance;
-	type CustomMetadata = CustomMetadata;
-	type Event = Event;
-	type WeightInfo = ();
+    type AssetId = CurrencyId;
+    type AssetProcessor = CustomAssetProcessor;
+    type AuthorityOrigin = AsEnsureOriginWithArg<EnsureRootOrTwoThirdsCouncil>;
+    type Balance = Balance;
+    type CustomMetadata = CustomMetadata;
+    type Event = Event;
+    type WeightInfo = ();
 }
 
 #[cfg(feature = "parachain")]

runtime/battery-station/src/xcm_config.rs

@@ -20,4 +20,4 @@
 pub mod asset_registry;
 pub mod config;
 pub mod fees;
-pub mod parachains;
+pub mod parachains;

runtime/battery-station/src/xcm_config/asset_registry.rs

@@ -18,8 +18,8 @@
 use crate::{Balance, CurrencyId};
 use orml_traits::asset_registry::{AssetMetadata, AssetProcessor};
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
-use sp_runtime::DispatchError;
 use scale_info::TypeInfo;
+use sp_runtime::DispatchError;
 
 #[derive(
     Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Debug, Encode, Decode, TypeInfo, MaxEncodedLen,
@@ -48,47 +48,47 @@ impl AssetProcessor<CurrencyId, AssetMetadata<Balance, CustomMetadata>> for Cust
 }
 
 #[derive(
-	Clone,
-	Copy,
-	Default,
-	PartialOrd,
-	Ord,
-	PartialEq,
-	Eq,
-	Debug,
-	Encode,
-	Decode,
-	TypeInfo,
-	MaxEncodedLen,
+    Clone,
+    Copy,
+    Default,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Debug,
+    Encode,
+    Decode,
+    TypeInfo,
+    MaxEncodedLen,
 )]
 /// Custom XC asset metadata
 pub struct CustomMetadata {
-	/// XCM-related metadata.
-	pub xcm: XcmMetadata,
+    /// XCM-related metadata.
+    pub xcm: XcmMetadata,
 
-	/// Whether an asset can be used in pools.
-	pub allow_in_pool: bool,
+    /// Whether an asset can be used in pools.
+    pub allow_in_pool: bool,
 }
 
 #[derive(
-	Clone,
-	Copy,
-	Default,
-	PartialOrd,
-	Ord,
-	PartialEq,
-	Eq,
-	Debug,
-	Encode,
-	Decode,
-	TypeInfo,
-	MaxEncodedLen,
+    Clone,
+    Copy,
+    Default,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Debug,
+    Encode,
+    Decode,
+    TypeInfo,
+    MaxEncodedLen,
 )]
 pub struct XcmMetadata {
-	/// The factor used to determine the fee.
+    /// The factor used to determine the fee.
     /// It is multiplied by the fee that would have been paind in native currency, so it represents
     /// the ratio `native_price / other_asset_price`. It is a fixed point decimal number containing
     /// as many fractional decimals as the asset it is used for contains.
     /// Should be updated regularly.
-	pub fee_factor: Option<Balance>,
-}
+    pub fee_factor: Option<Balance>,
+}

runtime/battery-station/src/xcm_config/config.rs

@@ -15,34 +15,41 @@
 // You should have received a copy of the GNU General Public License
 // along with Zeitgeist. If not, see <https://www.gnu.org/licenses/>.
 
+use super::{
+    fees::{native_per_second, FixedConversionRateProvider},
+    parachains::zeitgeist::ZTG_KEY,
+};
 use crate::{
-    AssetManager, AccountId, Ancestry, Balance, Call, CurrencyId, MaxInstructions, Origin,
-    ParachainSystem, PolkadotXcm, RelayChainOrigin, RelayNetwork, 
-    UnitWeightCost, UnknownTokens, XcmpQueue, ZeitgeistTreasuryAccount, AssetRegistry
+    AccountId, Ancestry, AssetManager, AssetRegistry, Balance, Call, CurrencyId, MaxInstructions,
+    Origin, ParachainSystem, PolkadotXcm, RelayChainOrigin, RelayNetwork, UnitWeightCost,
+    UnknownTokens, XcmpQueue, ZeitgeistTreasuryAccount,
 };
-use super::{fees::{native_per_second, FixedConversionRateProvider}, parachains::zeitgeist::ZTG_KEY};
 
 use alloc::vec::Vec;
 use frame_support::{match_types, parameter_types, traits::Everything};
 use orml_asset_registry::{AssetRegistryTrader, FixedRateAssetRegistryTrader};
-use orml_traits::{MultiCurrency, location::AbsoluteReserveProvider};
-use orml_xcm_support::{DepositToAlternative, IsNativeConcrete, MultiCurrencyAdapter, MultiNativeAsset, UnknownAsset};
+use orml_traits::{location::AbsoluteReserveProvider, MultiCurrency};
+use orml_xcm_support::{
+    DepositToAlternative, IsNativeConcrete, MultiCurrencyAdapter, MultiNativeAsset, UnknownAsset,
+};
 use pallet_xcm::XcmPassthrough;
 use polkadot_parachain::primitives::Sibling;
 use sp_runtime::traits::Convert;
-use xcm::latest::{
-    prelude::{GeneralKey, X1, AssetId, Concrete, MultiAsset},
-    BodyId, Junction, Junctions, MultiLocation,
+use xcm::{
+    latest::{
+        prelude::{AssetId, Concrete, GeneralKey, MultiAsset, X1},
+        BodyId, Junction, Junctions, MultiLocation,
+    },
+    opaque::latest::Fungibility::Fungible,
 };
 use xcm_builder::{
     AccountId32Aliases, AllowKnownQueryResponses, AllowSubscriptionsFrom,
-    AllowTopLevelPaidExecutionFrom, FixedWeightBounds, FixedRateOfFungible, LocationInverter, 
+    AllowTopLevelPaidExecutionFrom, FixedRateOfFungible, FixedWeightBounds, LocationInverter,
     ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
-    SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
-    TakeRevenue,
+    SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeRevenue,
+    TakeWeightCredit,
 };
 use xcm_executor::Config;
-use xcm::opaque::latest::Fungibility::Fungible;
 use zeitgeist_primitives::types::Asset;
 
 pub struct XcmConfig;
@@ -77,7 +84,9 @@ impl Config for XcmConfig {
     type SubscriptionService = PolkadotXcm;
     /// The means of purchasing weight credit for XCM execution.
     type Trader = Trader;
-    /// TODO: The means of determining an XCM message's weight.
+    /// The means of determining an XCM message's weight.
+    // Adds UnitWeightCost per instruction plus the weight of each instruction.
+    // The total number of instructions are bounded by MaxInstructions
     type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
     /// How to send an onward XCM message.
     type XcmSender = XcmRouter;
@@ -100,49 +109,45 @@ pub type Barrier = (
 pub type Trader = (
     // In case the asset in question is the native currency, it will charge
     // the default base fee per second and deposits them into treasury
-	FixedRateOfFungible<ZtgPerSecond, ToTreasury>,
+    FixedRateOfFungible<ZtgPerSecond, ToTreasury>,
     // For all other assets the base fee per second will tried to be derived
     // through the `fee_factor` entry in the asset registry. If the asset is
     // not present in the asset registry, the default base fee per second is used.
     // Deposits all fees into the treasury.
-	AssetRegistryTrader<
-		FixedRateAssetRegistryTrader<FixedConversionRateProvider<AssetRegistry>>,
-		ToTreasury,
-	>,
+    AssetRegistryTrader<
+        FixedRateAssetRegistryTrader<FixedConversionRateProvider<AssetRegistry>>,
+        ToTreasury,
+    >,
 );
 
 pub struct ToTreasury;
 impl TakeRevenue for ToTreasury {
-	fn take_revenue(revenue: MultiAsset) {
+    fn take_revenue(revenue: MultiAsset) {
         use xcm_executor::traits::Convert;
 
-		if let MultiAsset {
-			id: Concrete(location),
-			fun: Fungible(amount),
-		} = revenue.clone()
-		{
-			if let Ok(asset_id) =
-				<AssetConvert as Convert<MultiLocation, CurrencyId>>::convert(location.clone())
-			{
-				let _ = AssetManager::deposit(asset_id, &ZeitgeistTreasuryAccount::get(), amount);
-			} else {
+        if let MultiAsset { id: Concrete(location), fun: Fungible(amount) } = revenue.clone() {
+            if let Ok(asset_id) =
+                <AssetConvert as Convert<MultiLocation, CurrencyId>>::convert(location.clone())
+            {
+                let _ = AssetManager::deposit(asset_id, &ZeitgeistTreasuryAccount::get(), amount);
+            } else {
                 // TODO this is wrong, use target as second parameter
                 let _ = UnknownTokens::deposit(&revenue, &location);
             }
-		}
-	}
+        }
+    }
 }
 
 parameter_types! {
     pub CheckAccount: AccountId = PolkadotXcm::check_account();
     /// The amount of ZTG charged per second of execution.
-	pub ZtgPerSecond: (AssetId, u128) = (
-		MultiLocation::new(
+    pub ZtgPerSecond: (AssetId, u128) = (
+        MultiLocation::new(
             0,
             X1(general_key(ZTG_KEY)),
         ).into(),
-		native_per_second(),
-	);
+        native_per_second(),
+    );
 }
 
 /// Means for transacting assets on this chain.
@@ -178,10 +183,7 @@ pub struct AssetConvert;
 impl Convert<CurrencyId, Option<MultiLocation>> for AssetConvert {
     fn convert(id: CurrencyId) -> Option<MultiLocation> {
         match id {
-            Asset::Ztg => Some(MultiLocation::new(
-                0,
-                X1(general_key(ZTG_KEY)),
-            ).into()),
+            Asset::Ztg => Some(MultiLocation::new(0, X1(general_key(ZTG_KEY))).into()),
             Asset::ForeignAsset(_) => AssetRegistry::multilocation(&id).ok()?,
             _ => None,
         }
@@ -194,13 +196,10 @@ impl Convert<CurrencyId, Option<MultiLocation>> for AssetConvert {
 impl xcm_executor::traits::Convert<MultiLocation, CurrencyId> for AssetConvert {
     fn convert(location: MultiLocation) -> Result<CurrencyId, MultiLocation> {
         match location.clone() {
-            MultiLocation {
-                parents: 0,
-                interior: X1(GeneralKey(key)),
-            } => match &key[..] {
+            MultiLocation { parents: 0, interior: X1(GeneralKey(key)) } => match &key[..] {
                 ZTG_KEY => Ok(CurrencyId::Ztg),
                 _ => AssetRegistry::location_to_asset_id(location.clone()).ok_or(location),
-            }
+            },
             _ => AssetRegistry::location_to_asset_id(location.clone()).ok_or(location),
         }
     }