New Asset System - Implement asset-router

Cargo.toml

@@ -6,6 +6,7 @@ default-members = [
     "runtime/battery-station",
     "runtime/zeitgeist",
     "zrml/authorized",
+    "zrml/asset-router",
     "zrml/court",
     "zrml/global-disputes",
     "zrml/liquidity-mining",
@@ -29,6 +30,7 @@ members = [
     "runtime/battery-station",
     "runtime/zeitgeist",
     "zrml/authorized",
+    "zrml/asset-router",
     "zrml/court",
     "zrml/global-disputes",
     "zrml/liquidity-mining",
@@ -229,6 +231,7 @@ zrml-swaps-rpc = { path = "zrml/swaps/rpc" }
 # Zeitgeist (wasm)
 common-runtime = { path = "runtime/common", default-features = false }
 zeitgeist-primitives = { path = "primitives", default-features = false }
+zrml-asset-router = { path = "zrml/asset-router", default-features = false }
 zrml-authorized = { path = "zrml/authorized", default-features = false }
 zrml-court = { path = "zrml/court", default-features = false }
 zrml-global-disputes = { path = "zrml/global-disputes", default-features = false }

primitives/src/assets/campaign_assets.rs

@@ -25,7 +25,7 @@ use super::*;
 #[derive(
     Clone, CompactAs, Copy, Debug, Decode, Default, Eq, Encode, MaxEncodedLen, PartialEq, TypeInfo,
 )]
-pub struct CampaignAssetClass(#[codec(compact)] pub(super) CampaignAssetId);
+pub struct CampaignAssetClass(#[codec(compact)] pub CampaignAssetId);
 
 impl From<Compact<CampaignAssetId>> for CampaignAssetClass {
     fn from(value: Compact<CampaignAssetId>) -> CampaignAssetClass {

primitives/src/assets/currencies.rs

@@ -17,10 +17,13 @@
 
 use super::*;
 
-/// The `CurrencyClass` enum represents all non-ztg currencies.
+/// The `CurrencyClass` enum represents all non-ztg CurrencyClass
+// used in orml-tokens
 #[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Decode, Eq, Encode, MaxEncodedLen, PartialEq, TypeInfo)]
+#[derive(
+    Clone, Copy, Debug, Decode, Eq, Encode, MaxEncodedLen, Ord, PartialEq, PartialOrd, TypeInfo,
+)]
 pub enum CurrencyClass<MI> {
     // All "Old" variants will be removed once the lazy migration from
     // orml-tokens to pallet-assets is complete

primitives/src/assets/custom_assets.rs

@@ -23,7 +23,7 @@ use super::*;
 #[derive(
     Clone, CompactAs, Copy, Debug, Decode, Default, Eq, Encode, MaxEncodedLen, PartialEq, TypeInfo,
 )]
-pub struct CustomAssetClass(#[codec(compact)] pub(super) CustomAssetId);
+pub struct CustomAssetClass(#[codec(compact)] pub CustomAssetId);
 
 impl From<Compact<CustomAssetId>> for CustomAssetClass {
     fn from(value: Compact<CustomAssetId>) -> CustomAssetClass {

primitives/src/constants/mock.rs

@@ -21,12 +21,22 @@
 pub use super::*;
 use crate::{
     assets::Asset,
-    types::{Assets, Balance, Moment},
+    types::{Assets, Balance, Currencies, Moment},
 };
 use frame_support::{parameter_types, traits::LockIdentifier, PalletId};
 use orml_traits::parameter_type_with_key;
 use sp_arithmetic::Perbill;
 
+// Assets
+parameter_types! {
+    pub const AssetsAccountDeposit: Balance = 0;
+    pub const AssetsApprovalDeposit: Balance = 0;
+    pub const AssetsDeposit: Balance = 0;
+    pub const AssetsStringLimit: u32 = 256;
+    pub const AssetsMetadataDepositBase: Balance = 0;
+    pub const AssetsMetadataDepositPerByte: Balance = 0;
+}
+
 // Authorized
 parameter_types! {
     pub const AuthorizedPalletId: PalletId = PalletId(*b"zge/atzd");
@@ -164,6 +174,7 @@ parameter_types! {
     pub const GetNativeCurrencyId: Assets = Asset::Ztg;
 }
 
+// Will be removed once asset-system is completely integerated
 parameter_type_with_key! {
     pub ExistentialDeposits: |currency_id: Assets| -> Balance {
         match currency_id {
@@ -173,6 +184,12 @@ parameter_type_with_key! {
     };
 }
 
+parameter_type_with_key! {
+    pub ExistentialDepositsNew: |_currency_id: Currencies| -> Balance {
+        1
+    };
+}
+
 // System
 parameter_types! {
     pub const BlockHashCount: u64 = 250;

primitives/src/types.rs

@@ -87,13 +87,13 @@ pub type Assets = Asset<MarketId>;
 /// Asset type representing campaign assets
 pub type CampaignAsset = CampaignAssetClass;
 
-// ID type for campaign asset class
+// ID type of the campaign asset class
 pub type CampaignAssetId = u128;
 
 /// Asset type representing custom assets
 pub type CustomAsset = CustomAssetClass;
 
-// ID type for campaign asset class
+// ID type of the custom asset class
 pub type CustomAssetId = u128;
 
 // Asset type representing currencies (excluding ZTG)
@@ -102,9 +102,6 @@ pub type Currencies = CurrencyClass<MarketId>;
 /// Asset type representing assets used by prediction markets
 pub type MarketAsset = MarketAssetClass<MarketId>;
 
-/// ID type for asset classes that anyone can create
-pub type AssetId = u128;
-
 /// The asset id specifically used for pallet_assets_tx_payment for
 /// paying transaction fees in different assets.
 /// Since the polkadot extension and wallets can't handle custom asset ids other than just u32,

runtime/battery-station/Cargo.toml

@@ -108,6 +108,7 @@ xcm-executor = { workspace = true, optional = true }
 
 common-runtime = { workspace = true }
 zeitgeist-primitives = { workspace = true }
+zrml-asset-router = { workspace = true }
 zrml-authorized = { workspace = true }
 zrml-court = { workspace = true }
 zrml-global-disputes = { workspace = true, optional = true }
@@ -382,6 +383,7 @@ try-runtime = [
     "orml-xtokens?/try-runtime",
 
     # Zeitgeist runtime pallets
+    "zrml-asset-router/try-runtime",
     "zrml-authorized/try-runtime",
     "zrml-court/try-runtime",
     "zrml-liquidity-mining/try-runtime",

runtime/battery-station/src/integration_tests/xcm/setup.rs

@@ -27,7 +27,7 @@ use xcm::{
     latest::{Junction::Parachain, Junctions::X2, MultiLocation},
     VersionedMultiLocation,
 };
-use zeitgeist_primitives::types::{Asset, CustomMetadata};
+use zeitgeist_primitives::types::{Currencies, CustomMetadata};
 
 pub(super) struct ExtBuilder {
     balances: Vec<(AccountId, Assets, Balance)>,
@@ -71,6 +71,9 @@ impl ExtBuilder {
                 .balances
                 .into_iter()
                 .filter(|(_, currency_id, _)| *currency_id != native_currency_id)
+                .map(|(account_id, currency_id, initial_balance)| {
+                    (account_id, currency_id.try_into().unwrap(), initial_balance)
+                })
                 .collect::<Vec<_>>(),
         }
         .assimilate_storage(&mut t)
@@ -103,10 +106,10 @@ pub const BOB: AccountId32 = AccountId32::new([1u8; 32]);
 pub const PARA_ID_SIBLING: u32 = 3000;
 
 /// IDs that are used to represent tokens from other chains
-pub const FOREIGN_ZTG_ID: Asset<u128> = Assets::ForeignAsset(0);
-pub const FOREIGN_PARENT_ID: Asset<u128> = Assets::ForeignAsset(1);
-pub const FOREIGN_SIBLING_ID: Asset<u128> = Assets::ForeignAsset(2);
-pub const BTC_ID: Asset<u128> = Assets::ForeignAsset(3);
+pub const FOREIGN_ZTG_ID: Currencies = Currencies::ForeignAsset(0);
+pub const FOREIGN_PARENT_ID: Currencies = Currencies::ForeignAsset(1);
+pub const FOREIGN_SIBLING_ID: Currencies = Currencies::ForeignAsset(2);
+pub const BTC_ID: Currencies = Currencies::ForeignAsset(3);
 
 #[inline]
 pub(super) const fn ztg(amount: Balance) -> Balance {

runtime/battery-station/src/integration_tests/xcm/test_net.rs

@@ -103,8 +103,8 @@ pub(super) fn para_ext(parachain_id: u32) -> sp_io::TestExternalities {
     ExtBuilder::default()
         .set_balances(vec![
             (ALICE, Assets::Ztg, ztg(10)),
-            (ALICE, FOREIGN_PARENT_ID, roc(10)),
-            (ZeitgeistTreasuryAccount::get(), FOREIGN_PARENT_ID, roc(1)),
+            (ALICE, FOREIGN_PARENT_ID.into(), roc(10)),
+            (ZeitgeistTreasuryAccount::get(), FOREIGN_PARENT_ID.into(), roc(1)),
         ])
         .set_parachain_id(parachain_id)
         .build()

runtime/battery-station/src/integration_tests/xcm/tests/currency_id_convert.rs

@@ -62,18 +62,18 @@ fn convert_any_registered_parent_multilocation() {
             foreign_parent_multilocation()
         );
 
-        assert_eq!(<AssetConvert as C2<_, _>>::convert(FOREIGN_PARENT_ID), None);
+        assert_eq!(<AssetConvert as C2<_, _>>::convert(Assets::from(FOREIGN_PARENT_ID)), None);
 
         // Register parent as foreign asset in the Zeitgeist parachain
         register_foreign_parent(None);
 
         assert_eq!(
             <AssetConvert as C1<_, _>>::convert(foreign_parent_multilocation()),
-            Ok(FOREIGN_PARENT_ID),
+            Ok(FOREIGN_PARENT_ID.into()),
         );
 
         assert_eq!(
-            <AssetConvert as C2<_, _>>::convert(FOREIGN_PARENT_ID),
+            <AssetConvert as C2<_, _>>::convert(Assets::from(FOREIGN_PARENT_ID)),
             Some(foreign_parent_multilocation())
         );
     });
@@ -87,18 +87,18 @@ fn convert_any_registered_sibling_multilocation() {
             foreign_sibling_multilocation()
         );
 
-        assert_eq!(<AssetConvert as C2<_, _>>::convert(FOREIGN_SIBLING_ID), None);
+        assert_eq!(<AssetConvert as C2<_, _>>::convert(Assets::from(FOREIGN_SIBLING_ID)), None);
 
         // Register sibling as foreign asset in the Zeitgeist parachain
         register_foreign_sibling(None);
 
         assert_eq!(
             <AssetConvert as C1<_, _>>::convert(foreign_sibling_multilocation()),
-            Ok(FOREIGN_SIBLING_ID),
+            Ok(FOREIGN_SIBLING_ID.into()),
         );
 
         assert_eq!(
-            <AssetConvert as C2<_, _>>::convert(FOREIGN_SIBLING_ID),
+            <AssetConvert as C2<_, _>>::convert(Assets::from(FOREIGN_SIBLING_ID)),
             Some(foreign_sibling_multilocation())
         );
     });

runtime/battery-station/src/integration_tests/xcm/tests/transfers.rs

@@ -126,7 +126,7 @@ fn transfer_ztg_sibling_to_zeitgeist() {
         assert_eq!(Tokens::free_balance(FOREIGN_ZTG_ID, &BOB), bob_initial_balance);
         assert_ok!(XTokens::transfer(
             RuntimeOrigin::signed(BOB),
-            FOREIGN_ZTG_ID,
+            FOREIGN_ZTG_ID.into(),
             transfer_amount,
             Box::new(
                 MultiLocation::new(
@@ -250,7 +250,7 @@ fn transfer_btc_zeitgeist_to_sibling() {
     Zeitgeist::execute_with(|| {
         assert_ok!(XTokens::transfer(
             RuntimeOrigin::signed(ALICE),
-            BTC_ID,
+            BTC_ID.into(),
             transfer_amount,
             Box::new(
                 MultiLocation::new(
@@ -328,7 +328,7 @@ fn transfer_roc_to_relay_chain() {
 
         assert_ok!(XTokens::transfer(
             RuntimeOrigin::signed(ALICE),
-            FOREIGN_PARENT_ID,
+            FOREIGN_PARENT_ID.into(),
             transfer_amount,
             Box::new(
                 MultiLocation::new(1, X1(Junction::AccountId32 { id: BOB.into(), network: None }))

runtime/battery-station/src/parameters.rs

@@ -497,16 +497,17 @@ parameter_type_with_key! {
     // are cleaned up automatically. In case of scalar outcomes, the market account can have dust.
     // Unless LPs use `pool_exit_with_exact_asset_amount`, there can be some dust pool shares remaining.
     // Explicit match arms are used to ensure new asset types are respected.
-    pub ExistentialDeposits: |currency_id: Assets| -> Balance {
+    pub ExistentialDeposits: |currency_id: Currencies| -> Balance {
         match currency_id {
-            Asset::CategoricalOutcome(_,_) => ExistentialDeposit::get(),
-            Asset::PoolShare(_)  => ExistentialDeposit::get(),
-            Asset::ScalarOutcome(_,_)  => ExistentialDeposit::get(),
+            Currencies::OldCategoricalOutcome(_,_) => ExistentialDeposit::get(),
+            Currencies::OldParimutuelShare(_,_)  => ExistentialDeposit::get(),
+            Currencies::OldPoolShare(_)  => ExistentialDeposit::get(),
+            Currencies::OldScalarOutcome(_,_)  => ExistentialDeposit::get(),
             #[cfg(feature = "parachain")]
-            Asset::ForeignAsset(id) => {
+            Currencies::ForeignAsset(id) => {
                 let maybe_metadata = <
                     orml_asset_registry::Pallet<Runtime> as orml_traits::asset_registry::Inspect
-                >::metadata(&Asset::ForeignAsset(*id));
+                >::metadata(&Currencies::ForeignAsset(*id));
 
                 if let Some(metadata) = maybe_metadata {
                     return metadata.existential_deposit;
@@ -515,17 +516,7 @@ parameter_type_with_key! {
                 1
             }
             #[cfg(not(feature = "parachain"))]
-            Asset::ForeignAsset(_) => ExistentialDeposit::get(),
-            Asset::Ztg => ExistentialDeposit::get(),
-            Asset::ParimutuelShare(_,_) => ExistentialDeposit::get(),
-
-            // The following assets are irrelevant, as they are managed by pallet-assets
-            Asset::NewParimutuelShare(_,_)
-            | Asset::NewCategoricalOutcome(_, _)
-            | Asset::NewScalarOutcome(_,_)
-            | Asset::NewPoolShare(_)
-            | Asset::CustomAssetClass(_)
-            | Asset::CampaignAssetClass(_)  => ExistentialDeposit::get(),
+            Currencies::ForeignAsset(_) => ExistentialDeposit::get(),
         }
     };
 }

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

@@ -15,7 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Zeitgeist. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Assets, Balance};
+use crate::{Balance, Currencies};
 use orml_traits::asset_registry::{AssetMetadata, AssetProcessor};
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
@@ -29,19 +29,19 @@ use zeitgeist_primitives::types::CustomMetadata;
 /// Only pre check is to ensure an asset id was passed.
 pub struct CustomAssetProcessor;
 
-impl AssetProcessor<Assets, AssetMetadata<Balance, CustomMetadata>> for CustomAssetProcessor {
+impl AssetProcessor<Currencies, AssetMetadata<Balance, CustomMetadata>> for CustomAssetProcessor {
     fn pre_register(
-        id: Option<Assets>,
+        id: Option<Currencies>,
         metadata: AssetMetadata<Balance, CustomMetadata>,
-    ) -> Result<(Assets, AssetMetadata<Balance, CustomMetadata>), DispatchError> {
+    ) -> Result<(Currencies, AssetMetadata<Balance, CustomMetadata>), DispatchError> {
         match id {
             Some(id) => Ok((id, metadata)),
             None => Err(DispatchError::Other("asset-registry: AssetId is required")),
         }
     }
 
     fn post_register(
-        _id: Assets,
+        _id: Currencies,
         _asset_metadata: AssetMetadata<Balance, CustomMetadata>,
     ) -> Result<(), DispatchError> {
         Ok(())