feat: Connectors v2 message PoC

libs/primitives/src/lib.rs

@@ -249,6 +249,9 @@ pub mod constants {
 	pub const fn deposit(items: u32, bytes: u32) -> Balance {
 		items as Balance * 15 * CENTI_CFG + (bytes as Balance) * 6 * CENTI_CFG
 	}
+
+	/// The prefix for tokens managed by Connectors.
+	pub const GENERAL_CURRENCY_INDEX_PREFIX: [u8; 12] = *b"CfgCnctTknId";
 }
 
 /// Listing of parachains we integrate with.

libs/traits/src/lib.rs

@@ -630,3 +630,13 @@ pub trait TransferAllowance<AccountId> {
 		currency: Self::CurrencyId,
 	) -> DispatchResult;
 }
+
+/// A trait that enables mapping a currency type to some general index with a distinct prefix.
+pub trait GeneralCurrencyIndex<Prefix> {
+	type CurrencyId;
+	type GeneralIndex;
+
+	/// Returns the `GeneralIndex` of a currency as a concatenation of the generic prefix
+	/// and its local currency identifier.
+	fn get_general_index(currency: Self::CurrencyId) -> Result<Self::GeneralIndex, DispatchError>;
+}

libs/types/src/tokens.rs

@@ -11,12 +11,13 @@
 // GNU General Public License for more details.
 
 use cfg_primitives::types::{PoolId, TrancheId};
-use cfg_traits::TrancheCurrency as TrancheCurrencyT;
+use cfg_traits::{GeneralCurrencyIndex, TrancheCurrency as TrancheCurrencyT};
 use codec::{Decode, Encode, MaxEncodedLen};
 pub use orml_asset_registry::AssetMetadata;
 use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Deserialize, Serialize};
+use sp_runtime::{traits::Get, DispatchError, TokenError};
 
 use crate::xcm::XcmMetadata;
 
@@ -79,6 +80,29 @@ impl From<StakingCurrency> for CurrencyId {
 	}
 }
 
+impl<Prefix> GeneralCurrencyIndex<Prefix> for CurrencyId
+where
+	Prefix: Get<[u8; 12]>,
+{
+	type CurrencyId = CurrencyId;
+	type GeneralIndex = u128;
+
+	fn get_general_index(
+		currency_id: Self::CurrencyId,
+	) -> Result<Self::GeneralIndex, DispatchError> {
+		let mut bytes = [0u8; 16];
+		bytes[..12].copy_from_slice(&Prefix::get());
+
+		let currency_bytes: [u8; 4] = match currency_id {
+			CurrencyId::ForeignAsset(id32) => Ok(id32.to_be_bytes()),
+			_ => Err(DispatchError::Token(TokenError::Unsupported)),
+		}?;
+
+		bytes[12..].copy_from_slice(&currency_bytes[..]);
+		Ok(u128::from_be_bytes(bytes))
+	}
+}
+
 /// A Currency that is solely used by tranches.
 ///
 /// We distinguish here between the enum variant CurrencyId::Tranche(PoolId, TranchId)
@@ -150,4 +174,7 @@ pub struct CustomMetadata {
 
 	/// Whether an asset can be used as a currency to fund Centrifuge Pools.
 	pub pool_currency: bool,
+	// TODO: Enable in follow-up PR
+	// /// The corresponding 20-byte EVM address of the asset.
+	// pub evm_address: [u8; 20],
 }

pallets/connectors/src/lib.rs

@@ -13,19 +13,22 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 use core::convert::TryFrom;
 
-use cfg_traits::PoolInspect;
+use cfg_traits::{GeneralCurrencyIndex, PoolInspect};
 use cfg_types::domain_address::{Domain, DomainAddress, DomainLocator};
 use cfg_utils::{decode_be_bytes, vec_to_fixed_array};
 use codec::{Decode, Encode, Input, MaxEncodedLen};
-use frame_support::traits::{
-	fungibles::{Inspect, Mutate, Transfer},
-	OriginTrait,
+use frame_support::{
+	ensure,
+	traits::{
+		fungibles::{Inspect, Mutate, Transfer},
+		OriginTrait,
+	},
 };
 use orml_traits::asset_registry::{self, Inspect as _};
 pub use pallet::*;
 use scale_info::TypeInfo;
 use sp_core::U256;
-use sp_runtime::{traits::AtLeast32BitUnsigned, FixedPointNumber};
+use sp_runtime::{traits::AtLeast32BitUnsigned, DispatchError, FixedPointNumber};
 use sp_std::{convert::TryInto, vec, vec::Vec};
 pub mod weights;
 
@@ -94,7 +97,7 @@ pub type TrancheIdOf<T> = <<T as Config>::PoolInspect as PoolInspect<
 pub type MessageOf<T> =
 	Message<Domain, PoolIdOf<T>, TrancheIdOf<T>, <T as Config>::Balance, <T as Config>::Rate>;
 
-pub type CurrencyIdOf<T> = <T as pallet_xcm_transactor::Config>::CurrencyId;
+pub type CurrencyIdOf<T> = <T as Config>::CurrencyId;
 
 #[frame_support::pallet]
 pub mod pallet {
@@ -162,6 +165,25 @@ pub mod pallet {
 			Balance = <Self as Config>::Balance,
 			CustomMetadata = CustomMetadata,
 		>;
+
+		/// The currency type of transferrable token.
+		type CurrencyId: Parameter
+			+ Member
+			+ Copy
+			+ MaybeSerializeDeserialize
+			+ Ord
+			+ TypeInfo
+			+ MaxEncodedLen
+			+ Into<<Self as pallet_xcm_transactor::Config>::CurrencyId>
+			+ GeneralCurrencyIndex<
+				<Self as Config>::GeneralCurrencyPrefix,
+				CurrencyId = <Self as Config>::CurrencyId,
+				GeneralIndex = u128,
+			>;
+
+		/// The prefix for currencies added via Connectors.
+		#[pallet::constant]
+		type GeneralCurrencyPrefix: Get<[u8; 12]>;
 	}
 
 	#[pallet::event]
@@ -196,6 +218,8 @@ pub mod pallet {
 
 	#[pallet::error]
 	pub enum Error<T> {
+		/// Failed to map the asset to its u128 representation
+		AssetNotFound,
 		/// A pool could not be found
 		PoolNotFound,
 		/// A tranche could not be found
@@ -276,6 +300,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			pool_id: PoolIdOf<T>,
 			tranche_id: TrancheIdOf<T>,
+			decimals: u8,
 			domain: Domain,
 		) -> DispatchResult {
 			let who = ensure_signed(origin.clone())?;
@@ -301,6 +326,7 @@ pub mod pallet {
 				Message::AddTranche {
 					pool_id,
 					tranche_id,
+					decimals,
 					token_name,
 					token_symbol,
 					price,
@@ -328,7 +354,7 @@ pub mod pallet {
 
 			Self::do_send_message(
 				who,
-				Message::UpdateTokenPrice {
+				Message::UpdateTrancheTokenPrice {
 					pool_id,
 					tranche_id,
 					price,
@@ -393,7 +419,7 @@ pub mod pallet {
 		/// Transfer tranche tokens to a given address
 		#[pallet::weight(< T as Config >::WeightInfo::transfer())]
 		#[pallet::call_index(6)]
-		pub fn transfer(
+		pub fn transfer_tranche_tokens(
 			origin: OriginFor<T>,
 			pool_id: PoolIdOf<T>,
 			tranche_id: TrancheIdOf<T>,
@@ -427,13 +453,89 @@ pub mod pallet {
 			)?;
 
 			Self::do_send_message(
-				who,
-				Message::Transfer {
+				who.clone(),
+				Message::TransferTrancheTokens {
 					pool_id,
 					tranche_id,
 					amount,
 					domain: domain_address.domain(),
-					address: domain_address.address(),
+					receiver: domain_address.address(),
+					sender: who
+						.encode()
+						.try_into()
+						.map_err(|_| DispatchError::Other("Conversion to 32 bytes failed"))?,
+				},
+				domain_address.domain(),
+			)?;
+
+			Ok(())
+		}
+
+		/// Transfer non-tranche tokens to a given address
+		#[pallet::weight(< T as Config >::WeightInfo::transfer())]
+		#[pallet::call_index(7)]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			asset_id: CurrencyIdOf<T>,
+			domain_address: DomainAddress,
+			amount: <T as pallet::Config>::Balance,
+		) -> DispatchResult {
+			let who = ensure_signed(origin.clone())?;
+
+			ensure!(!amount.is_zero(), Error::<T>::InvalidTransferAmount);
+
+			// Transfer to the domain account for bookkeeping
+			T::Tokens::transfer(
+				asset_id,
+				&who,
+				&DomainLocator::<Domain> {
+					domain: domain_address.domain(),
+				}
+				.into_account_truncating(),
+				amount,
+				false,
+			)?;
+
+			Self::do_send_message(
+				who.clone(),
+				Message::Transfer {
+					amount,
+					currency: <Pallet<T> as GeneralCurrencyIndex<
+						<T as Config>::GeneralCurrencyPrefix,
+					>>::get_general_index(asset_id)?,
+					sender: who
+						.encode()
+						.try_into()
+						.map_err(|_| DispatchError::Other("Conversion to 32 bytes failed"))?,
+					receiver: domain_address.address(),
+				},
+				domain_address.domain(),
+			)?;
+
+			Ok(())
+		}
+
+		/// Add a CurrencyId to the set of known currencies, enabling that currency for Pool creation.
+		// TODO: Replace weight after benchmarking
+		#[pallet::weight(< T as Config >::WeightInfo::add_connector())]
+		#[pallet::call_index(8)]
+		pub fn add_currency(
+			origin: OriginFor<T>,
+			currency_id: CurrencyIdOf<T>,
+			domain_address: DomainAddress,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let general_index = <Pallet<T> as GeneralCurrencyIndex<
+				<T as Config>::GeneralCurrencyPrefix,
+			>>::get_general_index(currency_id)?;
+
+			Self::do_send_message(
+				who,
+				Message::AddCurrency {
+					currency: general_index,
+					// FIXME: In PR which adds evm_address to AssetRegistry
+					evm_address: [0u8; 20],
 				},
 				domain_address.domain(),
 			)?;
@@ -491,7 +593,7 @@ pub mod pallet {
 				fee_payer,
 				// The currency in which we want to pay fees
 				CurrencyPayment {
-					currency: Currency::AsCurrencyId(xcm_domain.fee_currency),
+					currency: Currency::AsCurrencyId(xcm_domain.fee_currency.into()),
 					fee_amount: None,
 				},
 				// The call to be executed in the destination chain
@@ -553,6 +655,25 @@ pub mod pallet {
 	}
 }
 
+impl<T, Prefix> GeneralCurrencyIndex<Prefix> for Pallet<T>
+where
+	T: pallet::Config,
+{
+	type CurrencyId = <T as pallet::Config>::CurrencyId;
+	type GeneralIndex = u128;
+
+	fn get_general_index(
+		currency: <T as pallet::Config>::CurrencyId,
+	) -> Result<Self::GeneralIndex, DispatchError> {
+		ensure!(
+			<T as Config>::AssetRegistry::metadata(&currency).is_some(),
+			Error::<T>::AssetNotFound
+		);
+
+		CurrencyIdOf::<T>::get_general_index(currency)
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use cfg_primitives::AccountId;