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/types/src/tokens.rs

@@ -10,13 +10,16 @@
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
+use core::marker::PhantomData;
+
 use cfg_primitives::types::{PoolId, TrancheId};
 use cfg_traits::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 +82,55 @@ impl From<StakingCurrency> for CurrencyId {
 	}
 }
 
+/// A general index wrapper for a given currency representation which is the concatenation
+/// of the generic prefix and the identifier of the respective currency.
+pub struct GeneralCurrencyIndex<Index, Prefix> {
+	pub index: Index,
+	_phantom: PhantomData<Prefix>,
+}
+
+impl<Index, Prefix> TryInto<GeneralCurrencyIndex<Index, Prefix>> for CurrencyId
+where
+	Index: From<u128>,
+	Prefix: Get<[u8; 12]>,
+{
+	type Error = DispatchError;
+
+	fn try_into(self) -> Result<GeneralCurrencyIndex<Index, Prefix>, Self::Error> {
+		let mut bytes = [0u8; 16];
+		bytes[..12].copy_from_slice(&Prefix::get());
+
+		let currency_bytes: [u8; 4] = match &self {
+			CurrencyId::ForeignAsset(id32) => Ok(id32.to_be_bytes()),
+			_ => Err(DispatchError::Token(TokenError::Unsupported)),
+		}?;
+		bytes[12..].copy_from_slice(&currency_bytes[..]);
+
+		Ok(GeneralCurrencyIndex {
+			index: u128::from_be_bytes(bytes).into(),
+			_phantom: Default::default(),
+		})
+	}
+}
+
+impl<Index, Prefix> TryFrom<GeneralCurrencyIndex<Index, Prefix>> for CurrencyId
+where
+	Index: Into<u128>,
+	Prefix: Get<[u8; 12]>,
+{
+	type Error = DispatchError;
+
+	fn try_from(value: GeneralCurrencyIndex<Index, Prefix>) -> Result<Self, Self::Error> {
+		let bytes: [u8; 16] = value.index.into().to_be_bytes();
+		let currency_bytes: [u8; 4] = bytes[12..]
+			.try_into()
+			// should never throw but lets be safe
+			.map_err(|_| DispatchError::Corruption)?;
+
+		Ok(CurrencyId::ForeignAsset(u32::from_be_bytes(currency_bytes)))
+	}
+}
+
 /// A Currency that is solely used by tranches.
 ///
 /// We distinguish here between the enum variant CurrencyId::Tranche(PoolId, TranchId)
@@ -151,3 +203,66 @@ pub struct CustomMetadata {
 	/// Whether an asset can be used as a currency to fund Centrifuge Pools.
 	pub pool_currency: bool,
 }
+
+#[cfg(test)]
+mod tests {
+	use frame_support::parameter_types;
+
+	use super::*;
+
+	const FOREIGN: CurrencyId = CurrencyId::ForeignAsset(1u32);
+
+	parameter_types! {
+		pub const ZeroPrefix: [u8; 12] = [0u8; 12];
+		pub const NonZeroPrefix: [u8; 12] = *b"TestPrefix12";
+	}
+
+	#[test]
+	fn zero_prefix_general_index_conversion() {
+		let general_index: GeneralCurrencyIndex<u128, ZeroPrefix> = FOREIGN.try_into().unwrap();
+		assert_eq!(general_index.index, 1u128);
+
+		// check identity condition on reverse conversion
+		let reconvert = CurrencyId::try_from(general_index).unwrap();
+		assert_eq!(reconvert, CurrencyId::ForeignAsset(1u32));
+	}
+
+	#[test]
+	fn non_zero_prefix_general_index_conversion() {
+		let general_index: GeneralCurrencyIndex<u128, NonZeroPrefix> = FOREIGN.try_into().unwrap();
+		assert_eq!(
+			general_index.index,
+			112181915321113319688489505016241979393u128
+		);
+
+		// check identity condition on reverse conversion
+		let reconvert = CurrencyId::try_from(general_index).unwrap();
+		assert_eq!(reconvert, CurrencyId::ForeignAsset(1u32));
+	}
+
+	#[test]
+	fn non_foreign_asset_general_index_conversion() {
+		assert!(
+			TryInto::<GeneralCurrencyIndex<u128, ZeroPrefix>>::try_into(CurrencyId::Native)
+				.is_err()
+		);
+		assert!(
+			TryInto::<GeneralCurrencyIndex<u128, ZeroPrefix>>::try_into(CurrencyId::Tranche(
+				2, [1u8; 16]
+			))
+			.is_err()
+		);
+		assert!(
+			TryInto::<GeneralCurrencyIndex<u128, ZeroPrefix>>::try_into(CurrencyId::KSM).is_err()
+		);
+		assert!(
+			TryInto::<GeneralCurrencyIndex<u128, ZeroPrefix>>::try_into(CurrencyId::AUSD).is_err()
+		);
+		assert!(
+			TryInto::<GeneralCurrencyIndex<u128, ZeroPrefix>>::try_into(CurrencyId::Staking(
+				StakingCurrency::BlockRewards
+			))
+			.is_err()
+		);
+	}
+}

pallets/connectors/src/lib.rs

@@ -94,15 +94,15 @@ 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 {
 	use cfg_primitives::Moment;
 	use cfg_traits::{Permissions, PoolInspect, TrancheCurrency};
 	use cfg_types::{
 		permissions::{PermissionScope, PoolRole, Role},
-		tokens::CustomMetadata,
+		tokens::{CustomMetadata, GeneralCurrencyIndex},
 	};
 	use frame_support::{error::BadOrigin, pallet_prelude::*, traits::UnixTime};
 	use frame_system::pallet_prelude::*;
@@ -162,6 +162,24 @@ 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>
+			+ TryInto<
+				GeneralCurrencyIndex<u128, <Self as Config>::GeneralCurrencyPrefix>,
+				Error = DispatchError,
+			>;
+
+		/// The prefix for currencies added via Connectors.
+		#[pallet::constant]
+		type GeneralCurrencyPrefix: Get<[u8; 12]>;
 	}
 
 	#[pallet::event]
@@ -196,6 +214,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 +296,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 +322,7 @@ pub mod pallet {
 				Message::AddTranche {
 					pool_id,
 					tranche_id,
+					decimals,
 					token_name,
 					token_symbol,
 					price,
@@ -328,7 +350,7 @@ pub mod pallet {
 
 			Self::do_send_message(
 				who,
-				Message::UpdateTokenPrice {
+				Message::UpdateTrancheTokenPrice {
 					pool_id,
 					tranche_id,
 					price,
@@ -382,7 +404,7 @@ pub mod pallet {
 					pool_id,
 					tranche_id,
 					valid_until,
-					address: domain_address.address(),
+					member: domain_address.address(),
 				},
 				domain_address.domain(),
 			)?;
@@ -393,7 +415,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 +449,83 @@ 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: Self::try_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 on a given Domain.
+		// 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)?;
+
+			Self::do_send_message(
+				who,
+				Message::AddCurrency {
+					currency: Self::try_get_general_index(currency_id)?,
+					// FIXME: In PR which adds evm_address to AssetRegistry
+					evm_address: [0u8; 20],
 				},
 				domain_address.domain(),
 			)?;
@@ -491,7 +583,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
@@ -550,6 +642,26 @@ pub mod pallet {
 
 			encoded
 		}
+
+		/// Returns the `u128` general index of a currency as the concatenation of the
+		/// configured `GeneralCurrencyPrefix` and its local currency identifier.
+		///
+		/// Assumes the currency to be registered in the `AssetRegistry`.
+		pub fn try_get_general_index(
+			currency: <T as pallet::Config>::CurrencyId,
+		) -> Result<u128, DispatchError> {
+			ensure!(
+				<T as Config>::AssetRegistry::metadata(&currency).is_some(),
+				Error::<T>::AssetNotFound
+			);
+
+			let general_index: GeneralCurrencyIndex<
+				u128,
+				<T as pallet::Config>::GeneralCurrencyPrefix,
+			> = CurrencyIdOf::<T>::try_into(currency)?;
+
+			Ok(general_index.index)
+		}
 	}
 }