connectors: Wrapped token lookup

libs/traits/src/lib.rs

@@ -634,7 +634,7 @@ pub trait TransferAllowance<AccountId> {
 	type CurrencyId;
 	type Location: Member + Debug + Eq + PartialEq + TypeInfo + Encode + Decode + MaxEncodedLen;
 	/// Determines whether the `send` account is allowed to make a transfer to
-	/// the  `recieve` loocation with `currency` type currency. Returns result
+	/// the  `receive` location with `currency` type currency. Returns result
 	/// wrapped bool for whether allowance is allowed.
 	fn allowance(
 		send: AccountId,

libs/types/src/domain_address.rs

@@ -15,9 +15,7 @@ use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_core::TypeId;
 
-/// The EVM Chain ID
-/// The type should accomodate all chain ids listed on https://chainlist.org/.
-type EVMChainId = u64;
+use crate::EVMChainId;
 
 /// A Domain is a chain or network we can send a Connectors message to.
 /// The domain indices need to match those used in the EVM contracts and these

libs/types/src/lib.rs

@@ -30,3 +30,7 @@ pub mod permissions;
 pub mod time;
 pub mod tokens;
 pub mod xcm;
+
+/// The EVM Chain ID
+/// The type should accomodate all chain ids listed on https://chainlist.org/.
+type EVMChainId = u64;

libs/types/src/tokens.rs

@@ -20,8 +20,12 @@ use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Deserialize, Serialize};
 use sp_runtime::{traits::Get, DispatchError, TokenError};
+use xcm::{
+	latest::{MultiLocation, NetworkId},
+	prelude::{AccountKey20, GlobalConsensus, X2},
+};
 
-use crate::xcm::XcmMetadata;
+use crate::{xcm::XcmMetadata, EVMChainId};
 
 #[derive(
 	Clone,
@@ -66,7 +70,7 @@ pub enum CurrencyId {
 )]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 pub enum StakingCurrency {
-	/// An emulated internal, non-transferrable currency
+	/// An emulated internal, non-transferable currency
 	/// Its issuance and holding is handled inherently
 	BlockRewards,
 }
@@ -194,8 +198,8 @@ impl TrancheCurrencyT<PoolId, TrancheId> for TrancheCurrency {
 	MaxEncodedLen,
 )]
 pub struct CustomMetadata {
-	/// XCM-related metadata.
-	pub xcm: XcmMetadata,
+	/// The ways, if any, this token is cross-chain transferable
+	pub transferability: CrossChainTransferability,
 
 	/// Whether an asset can be minted.
 	/// When `true`, the right permissions will checked in the permissions
@@ -212,6 +216,107 @@ pub struct CustomMetadata {
 	pub pool_currency: bool,
 }
 
+/// The Cross Chain Transferability property of an asset describes the way(s),
+/// if any, that said asset is cross-chain transferable. It may currently be
+/// transferable through Xcm, Centrifuge Connectors, or All .
+///
+/// NOTE: Once set to `All`, the asset is automatically transferable through any
+/// eventual new option added at a later stage. A migration might be required if
+/// that's undesirable for any registered asset.
+#[derive(
+	Clone,
+	Copy,
+	Default,
+	PartialOrd,
+	Ord,
+	PartialEq,
+	Eq,
+	Debug,
+	Encode,
+	Decode,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum CrossChainTransferability {
+	/// The asset is not transferable cross-chain
+	#[default]
+	None,
+
+	/// The asset is only transferable through XCM
+	Xcm(XcmMetadata),
+
+	/// The asset is only transferable through Centrifuge Connectors
+	Connectors,
+
+	/// The asset is transferable through all available options
+	All(XcmMetadata),
+}
+
+impl CrossChainTransferability {
+	pub fn includes_xcm(self) -> bool {
+		self != Self::None && matches!(self, Self::Xcm(..) | Self::All(..))
+	}
+}
+
+/// Connectors wrapped tokens
+///
+/// Currently, Connectors are only deployed on EVM-based chains and therefore
+/// the only supported type of connectors-wrapped tokens are Evm tokens. In the
+/// far future, we might support wrapped tokens from other chains, such as
+/// Cosmos, Avalanche, etc.
+#[derive(
+	Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Debug, Encode, Decode, TypeInfo, MaxEncodedLen,
+)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum ConnectorsWrappedToken {
+	/// An EVM-native token
+	EVM {
+		/// The EVM chain id where the token is deployed
+		chain_id: EVMChainId,
+		/// The token contract address
+		address: [u8; 20],
+	},
+}
+
+impl TryFrom<MultiLocation> for ConnectorsWrappedToken {
+	type Error = ();
+
+	fn try_from(location: MultiLocation) -> Result<Self, Self::Error> {
+		match location {
+			MultiLocation {
+				parents: 0,
+				interior:
+					X2(
+						GlobalConsensus(NetworkId::Ethereum { chain_id }),
+						AccountKey20 {
+							network: None,
+							key: address,
+						},
+					),
+			} => Ok(Self::EVM { chain_id, address }),
+			_ => Err(()),
+		}
+	}
+}
+
+impl Into<MultiLocation> for ConnectorsWrappedToken {
+	fn into(self) -> MultiLocation {
+		match self {
+			Self::EVM { chain_id, address } => MultiLocation {
+				parents: 0,
+				interior: X2(
+					GlobalConsensus(NetworkId::Ethereum { chain_id }),
+					AccountKey20 {
+						network: None,
+						key: address,
+					},
+				),
+			},
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use frame_support::parameter_types;
@@ -273,4 +378,37 @@ mod tests {
 			.is_err()
 		);
 	}
+
+	#[test]
+	/// Verify that converting a ConnectorsWrappedToken to MultiLocation and
+	/// back results in the same original value.
+	fn connectors_wrapped_token_location_conversion_identity() {
+		const CHAIN_ID: EVMChainId = 123;
+		const ADDRESS: [u8; 20] = [9; 20];
+
+		let wrapped_token = ConnectorsWrappedToken::EVM {
+			chain_id: CHAIN_ID,
+			address: ADDRESS,
+		};
+		let as_location: MultiLocation = wrapped_token.into();
+
+		assert_eq!(
+			as_location,
+			MultiLocation {
+				parents: 0,
+				interior: X2(
+					GlobalConsensus(NetworkId::Ethereum { chain_id: CHAIN_ID }),
+					AccountKey20 {
+						network: None,
+						key: ADDRESS
+					},
+				),
+			}
+		);
+
+		assert_eq!(
+			ConnectorsWrappedToken::try_from(as_location),
+			Ok(wrapped_token)
+		);
+	}
 }

pallets/pool-system/src/tests/mod.rs

@@ -14,7 +14,7 @@ use cfg_traits::{PoolMutate, TrancheCurrency as TrancheCurrencyT};
 use cfg_types::{
 	epoch::EpochState,
 	fixed_point::Rate,
-	tokens::{CurrencyId, CustomMetadata, TrancheCurrency},
+	tokens::{CrossChainTransferability, CurrencyId, CustomMetadata, TrancheCurrency},
 	xcm::XcmMetadata,
 };
 use frame_support::{assert_err, assert_noop, assert_ok};
@@ -2319,9 +2319,7 @@ fn create_tranche_token_metadata() {
 					mintable: false,
 					permissioned: true,
 					pool_currency: false,
-					xcm: XcmMetadata {
-						fee_per_second: None,
-					},
+					transferability: CrossChainTransferability::Connectors,
 				},
 			}
 		);

pallets/pool-system/src/tranches.rs

@@ -17,9 +17,9 @@ use cfg_traits::{
 	ops::{EnsureAdd, EnsureFixedPointNumber, EnsureInto},
 	TrancheCurrency as TrancheCurrencyT,
 };
+use cfg_types::tokens::{CrossChainTransferability, CustomMetadata};
 #[cfg(test)]
 use cfg_types::{fixed_point::Rate, tokens::TrancheCurrency};
-use cfg_types::{tokens::CustomMetadata, xcm::XcmMetadata};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{
 	dispatch::DispatchResult,
@@ -248,9 +248,7 @@ where
 				mintable: false,
 				permissioned: true,
 				pool_currency: false,
-				xcm: XcmMetadata {
-					fee_per_second: None,
-				},
+				transferability: CrossChainTransferability::Connectors,
 			},
 		}
 	}

runtime/altair/src/lib.rs

@@ -59,7 +59,7 @@ use orml_traits::{currency::MutationHooks, parameter_type_with_key};
 use pallet_anchors::AnchorData;
 pub use pallet_balances::Call as BalancesCall;
 use pallet_collective::{EnsureMember, EnsureProportionMoreThan};
-use pallet_ethereum::{Transaction as EthereumTransaction, TransactionAction};
+use pallet_ethereum::Transaction as EthereumTransaction;
 use pallet_evm::{Account as EVMAccount, FeeCalculator, Runner};
 use pallet_investments::OrderType;
 use pallet_pool_system::{
@@ -72,11 +72,8 @@ pub use pallet_timestamp::Call as TimestampCall;
 pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment};
 use pallet_transaction_payment_rpc_runtime_api::{FeeDetails, RuntimeDispatchInfo};
 use polkadot_runtime_common::{prod_or_fast, BlockHashCount, SlowAdjustingFeeUpdate};
+use runtime_common::fees::{DealWithFees, WeightToFee};
 pub use runtime_common::*;
-use runtime_common::{
-	evm::GetTransactionAction,
-	fees::{DealWithFees, WeightToFee},
-};
 use scale_info::TypeInfo;
 use sp_api::impl_runtime_apis;
 use sp_core::{OpaqueMetadata, H160, H256, U256};
@@ -1676,6 +1673,9 @@ impl fp_self_contained::SelfContainedCall for RuntimeCall {
 
 	#[cfg(not(feature = "testnet-runtime"))]
 	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {
+		use pallet_ethereum::TransactionAction;
+		use runtime_common::evm::GetTransactionAction;
+
 		match self {
 			RuntimeCall::Ethereum(call) => match call {
 				pallet_ethereum::Call::transact { transaction }