Implement and configure AssetTransactor

primitives/src/asset.rs

@@ -18,6 +18,9 @@ pub enum Asset<MI: MaxEncodedLen> {
     ScalarOutcome(MI, ScalarPosition),
     CombinatorialOutcome,
     PoolShare(SerdeWrapper<PoolId>),
+    Ausd,
+    Ksm,
+    Roc,
     Ztg,
 }
 

runtime/Cargo.toml

@@ -64,11 +64,12 @@ pallet-author-mapping = { rev = "78db06c0203f61b35059304f7194ed5c10dcfda8", defa
 pallet-author-slot-filter = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/nimbus", optional = true }
 pallet-crowdloan-rewards = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/crowdloan-rewards", optional = true }
 parachain-staking = { rev = "78db06c0203f61b35059304f7194ed5c10dcfda8", default-features = false, git = "https://github.com/purestake/moonbeam", optional = true }
+polkadot-parachain = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
 
-# Polkadot
-
+# XCM
+orml-xcm-support = { branch = "polkadot-0.9.19-latest", default-features = false, git = "https://github.com/zeitgeistpm/open-runtime-module-library", optional = true }
+orml-unknown-tokens = { branch = "polkadot-0.9.19-latest", default-features = false, git = "https://github.com/zeitgeistpm/open-runtime-module-library", optional = true }
 pallet-xcm = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
-polkadot-parachain = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
 xcm = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
 xcm-builder = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
 xcm-executor = { branch = "moonbeam-polkadot-v0.9.19", default-features = false, git = "https://github.com/purestake/polkadot", optional = true }
@@ -123,11 +124,13 @@ parachain = [
     "pallet-author-slot-filter",
     "pallet-crowdloan-rewards",
     "parachain-staking",
+    "polkadot-parachain",
 
-    # Polkadot
+    # XCM
 
+    "orml-unknown-tokens",
+    "orml-xcm-support",
     "pallet-xcm",
-    "polkadot-parachain",
     "xcm-builder",
     "xcm-executor",
     "xcm",
@@ -239,11 +242,13 @@ std = [
     "pallet-author-slot-filter?/std",
     "pallet-crowdloan-rewards?/std",
     "parachain-staking?/std",
+    "polkadot-parachain?/std",
 
-    # Polkadot
+    # XCM
 
+    "orml-unknown-tokens?/std",
+    "orml-xcm-support?/std",
     "pallet-xcm?/std",
-    "polkadot-parachain?/std",
     "xcm-builder?/std",
     "xcm-executor?/std",
     "xcm?/std",

runtime/src/lib.rs

@@ -53,7 +53,7 @@ use {
     frame_system::EnsureSigned,
     nimbus_primitives::{CanAuthor, NimbusId},
     xcm_builder::{EnsureXcmOrigin, FixedWeightBounds, LocationInverter},
-    xcm_config::{XcmConfig, XcmOriginToTransactDispatchOrigin, LocalOriginToLocation, XcmRouter}
+    xcm_config::{LocalOriginToLocation, XcmConfig, XcmOriginToTransactDispatchOrigin, XcmRouter},
 };
 
 pub const VERSION: RuntimeVersion = RuntimeVersion {
@@ -204,6 +204,7 @@ macro_rules! create_zeitgeist_runtime {
                 // Third-party
                 Currency: orml_currencies::{Call, Pallet, Storage} = 40,
                 Tokens: orml_tokens::{Config<T>, Event<T>, Pallet, Storage} = 41,
+                UnknownTokens: orml_unknown_tokens::{Pallet, Storage, Event} = 42,
 
                 // Zeitgeist
                 MarketCommons: zrml_market_commons::{Pallet, Storage} = 50,
@@ -549,6 +550,10 @@ impl orml_tokens::Config for Runtime {
     type WeightInfo = weights::orml_tokens::WeightInfo<Runtime>;
 }
 
+impl orml_unknown_tokens::Config for Runtime {
+    type Event = Event;
+}
+
 #[cfg(feature = "parachain")]
 impl pallet_crowdloan_rewards::Config for Runtime {
     type Event = Event;

runtime/src/parachain_params.rs

@@ -10,7 +10,6 @@ use sp_runtime::{Perbill, Percent, SaturatedConversion};
 use xcm::latest::{Junction, MultiLocation, NetworkId};
 use zeitgeist_primitives::{constants::MICRO, types::Balance};
 
-
 parameter_types! {
     // Author-Mapping
     /// The amount that should be taken as a security deposit when registering a NimbusId.

runtime/src/parameters.rs

@@ -135,6 +135,7 @@ parameter_types! {
     pub const ProposalBondMaximum: Balance = 500 * BASE;
     pub const SpendPeriod: BlockNumber = 24 * BLOCKS_PER_DAY;
     pub const TreasuryPalletId: PalletId = PalletId(*b"zge/tsry");
+    pub ZeitgeistTreasuryAccount: AccountId = TreasuryPalletId::get().into_account();
 
     // Vesting
     pub const MinVestedTransfer: Balance = CENT;

runtime/src/weights/pallet_author_mapping.rs

@@ -33,22 +33,22 @@ pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_author_mapping::weights::WeightInfo for WeightInfo<T> {
     // Storage: AuthorMapping MappingWithDeposit (r:1 w:1)
     // Storage: System Account (r:1 w:1)
-	#[rustfmt::skip]
+    #[rustfmt::skip]
     fn add_association() -> Weight {
         (60_010_000 as Weight)
             .saturating_add(T::DbWeight::get().reads(2 as Weight))
             .saturating_add(T::DbWeight::get().writes(2 as Weight))
     }
     // Storage: AuthorMapping MappingWithDeposit (r:2 w:2)
-	#[rustfmt::skip]
+    #[rustfmt::skip]
     fn update_association() -> Weight {
         (45_540_000 as Weight)
             .saturating_add(T::DbWeight::get().reads(2 as Weight))
             .saturating_add(T::DbWeight::get().writes(2 as Weight))
     }
     // Storage: AuthorMapping MappingWithDeposit (r:1 w:1)
     // Storage: System Account (r:1 w:1)
-	#[rustfmt::skip]
+    #[rustfmt::skip]
     fn clear_association() -> Weight {
         (60_780_000 as Weight)
             .saturating_add(T::DbWeight::get().reads(2 as Weight))

runtime/src/xcm_config.rs

@@ -1,19 +1,25 @@
 use crate::{
-    AccountId, Ancestry, Balance, Balances, Call, MaxInstructions, Origin, ParachainSystem,
-    PolkadotXcm, RelayChainOrigin, RelayLocation, RelayNetwork, UnitWeightCost, XcmpQueue, 
+    AccountId, Ancestry, Balance, Balances, Call, Currency, MaxInstructions, Origin,
+    ParachainSystem, PolkadotXcm, RelayChainOrigin, RelayLocation, RelayNetwork, Runtime,
+    UnitWeightCost, UnknownTokens, XcmpQueue, ZeitgeistTreasuryAccount,
 };
-use frame_support::{match_types, traits::Everything, weights::IdentityFee};
+use frame_support::{match_types, parameter_types, traits::Everything, weights::IdentityFee};
+use orml_xcm_support::{DepositToAlternative, IsNativeConcrete, MultiCurrencyAdapter};
 use pallet_xcm::XcmPassthrough;
 use polkadot_parachain::primitives::Sibling;
+use sp_runtime::traits::Convert;
+use xcm::latest::{
+    prelude::{Concrete, GeneralKey, MultiAsset, Parachain, X1, X2},
+    BodyId, Junction, Junctions, MultiLocation,
+};
 use xcm_builder::{
-    AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,
-    FixedWeightBounds, IsConcrete, LocationInverter, NativeAsset, ParentIsPreset,
-    RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
-    SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
-    UsingComponents,
+    AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
+    FixedWeightBounds, LocationInverter, NativeAsset, ParentIsPreset, RelayChainAsNative,
+    SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative,
+    SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, UsingComponents,
 };
 use xcm_executor::Config;
-use xcm::latest::{BodyId, Junction, Junctions, MultiLocation};
+use zeitgeist_primitives::types::Asset;
 
 pub struct XcmConfig;
 
@@ -23,12 +29,12 @@ pub struct XcmConfig;
 impl Config for XcmConfig {
     /// The handler for when there is an instruction to claim assets.
     type AssetClaims = PolkadotXcm;
-    /// TODO: How to withdraw and deposit an asset.
-    type AssetTransactor = LocalAssetTransactor;
+    /// How to withdraw and deposit an asset.
+    type AssetTransactor = MultiAssetTransactor;
     /// The general asset trap - handler for when assets are left in the Holding Register at the
     /// end of execution.
     type AssetTrap = PolkadotXcm;
-    /// Additional filters that specify whether the XCM call should be executed at all.
+    /// TODO: Additional filters that specify whether the XCM call should be executed at all.
     type Barrier = Barrier;
     /// The outer call dispatch type.
     type Call = Call;
@@ -58,21 +64,136 @@ pub type Barrier = (
     AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,
     // ^^^ Parent and its exec plurality get free execution
 );
+type AssetT = <Runtime as orml_tokens::Config>::CurrencyId;
+
+parameter_types! {
+    pub CheckAccount: AccountId = PolkadotXcm::check_account();
+}
 
 /// Means for transacting assets on this chain.
-pub type LocalAssetTransactor = CurrencyAdapter<
-    // Use this currency:
-    Balances,
-    // Use this currency when it is a fungible asset matching the given location or name:
-    IsConcrete<RelayLocation>,
-    // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:
-    LocationToAccountId,
-    // Our chain's account ID type (we can't get away without mentioning it explicitly):
+pub type MultiAssetTransactor = MultiCurrencyAdapter<
+    // All known Assets will be processed by the following MultiCurrency implementation.
+    Currency,
+    // Any unknown Assets will be processed by the following implementation.
+    UnknownTokens,
+    // This means that this adapter should handle any token that `AssetConvert` can convert
+    // using Currency and UnknownTokens in all other cases.
+    IsNativeConcrete<AssetT, AssetConvert>,
+    // Our chain's account ID type (we can't get away without mentioning it explicitly).
     AccountId,
-    // We don't track any teleports.
-    (),
+    // Convert an XCM `MultiLocation` into a local account id.
+    LocationToAccountId,
+    // The AssetId that corresponds to the native currency.
+    AssetT,
+    // Struct that provides functions to convert `Asset` <=> `MultiLocation`.
+    AssetConvert,
+    // In case of deposit failure, known assets will be placed in treasury.
+    DepositToAlternative<ZeitgeistTreasuryAccount, Currency, AssetT, AccountId, Balance>,
 >;
 
+/// Listing of parachains we integrate with.
+/// For each parachain, we are interested in stating their parachain ID
+/// as well as any of their token key ID that we possibly support in our
+/// XCM configuration. These token keys are defined in said parachain
+/// and must always match the value there defined, which is expected to
+/// never change once defined since they help define the canonical id
+/// of said tokens in the network, which is relevant for XCM transfers.
+pub mod parachains {
+    pub mod karura {
+        pub const ID: u32 = 2000;
+        pub const AUSD_KEY: &[u8] = &[0, 129];
+    }
+
+    pub mod zeitgeist {
+        pub const ID: u32 = 2101;
+        pub const ZTG_KEY: &[u8] = &[0, 1];
+    }
+}
+
+/// AssetConvert
+/// This type implements conversions from our `Asset` type into `MultiLocation` and vice-versa.
+/// A currency locally is identified with a `Asset` variant but in the network it is identified
+/// in the form of a `MultiLocation`, in this case a pair (Para-Id, Currency-Id).
+pub struct AssetConvert;
+// TODO: Use KSM or ROC depending on runtime that's built
+const RELAY_CURRENCY: AssetT = Asset::Roc;
+
+/// Convert our `Asset` type into its `MultiLocation` representation.
+/// Other chains need to know how this conversion takes place in order to
+/// handle it on their side.
+impl Convert<AssetT, Option<MultiLocation>> for AssetConvert {
+    fn convert(id: AssetT) -> Option<MultiLocation> {
+        let x = match id {
+            RELAY_CURRENCY => MultiLocation::parent(),
+            Asset::Ausd => MultiLocation::new(
+                1,
+                X2(
+                    Parachain(parachains::karura::ID),
+                    GeneralKey(parachains::karura::AUSD_KEY.into()),
+                ),
+            ),
+            Asset::Ztg => MultiLocation::new(
+                1,
+                X2(
+                    Parachain(parachains::zeitgeist::ID),
+                    GeneralKey(parachains::zeitgeist::ZTG_KEY.to_vec()),
+                ),
+            ),
+            _ => return None,
+        };
+        Some(x)
+    }
+}
+
+/// Convert an incoming `MultiLocation` into a `Asset` if possible.
+/// Here we need to know the canonical representation of all the tokens we handle in order to
+/// correctly convert their `MultiLocation` representation into our internal `Asset` type.
+impl xcm_executor::traits::Convert<MultiLocation, AssetT> for AssetConvert {
+    fn convert(location: MultiLocation) -> Result<AssetT, MultiLocation> {
+        if location == MultiLocation::parent() {
+            return Ok(RELAY_CURRENCY);
+        }
+
+        match location.clone() {
+            MultiLocation { parents: 0, interior: X1(GeneralKey(key)) } => match &key[..] {
+                parachains::zeitgeist::ZTG_KEY => Ok(Asset::Ztg),
+                _ => Err(location.clone()),
+            },
+            MultiLocation { parents: 1, interior: X2(Parachain(para_id), GeneralKey(key)) } => {
+                match para_id {
+                    parachains::zeitgeist::ID => match &key[..] {
+                        parachains::zeitgeist::ZTG_KEY => Ok(Asset::Ztg),
+                        _ => Err(location.clone()),
+                    },
+
+                    parachains::karura::ID => match &key[..] {
+                        parachains::karura::AUSD_KEY => Ok(Asset::Ausd),
+                        _ => Err(location.clone()),
+                    },
+                    _ => Err(location.clone()),
+                }
+            }
+            _ => Err(location.clone()),
+        }
+    }
+}
+
+impl Convert<MultiAsset, Option<AssetT>> for AssetConvert {
+    fn convert(asset: MultiAsset) -> Option<AssetT> {
+        if let MultiAsset { id: Concrete(location), .. } = asset {
+            <AssetConvert as xcm_executor::traits::Convert<_, _>>::convert(location).ok()
+        } else {
+            None
+        }
+    }
+}
+
+impl Convert<MultiLocation, Option<AssetT>> for AssetConvert {
+    fn convert(location: MultiLocation) -> Option<AssetT> {
+        <AssetConvert as xcm_executor::traits::Convert<_, _>>::convert(location).ok()
+    }
+}
+
 /// No local origins on this chain are allowed to dispatch XCM sends/executions.
 pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, RelayNetwork>;