feat: add connectors v2 extrinsics & inbound msg handlers

libs/mocks/src/pools.rs

@@ -57,6 +57,10 @@ pub mod pallet {
 			register_call!(f);
 		}
 
+		pub fn mock_currency_for(f: impl Fn(T::PoolId) -> Option<T::CurrencyId> + 'static) {
+			register_call!(f);
+		}
+
 		pub fn mock_withdraw(
 			f: impl Fn(T::PoolId, T::AccountId, T::Balance) -> DispatchResult + 'static,
 		) {
@@ -102,6 +106,10 @@ pub mod pallet {
 		fn account_for(a: T::PoolId) -> T::AccountId {
 			execute_call!(a)
 		}
+
+		fn currency_for(a: T::PoolId) -> Option<T::CurrencyId> {
+			execute_call!(a)
+		}
 	}
 
 	impl<T: Config> PoolReserve<T::AccountId, T::CurrencyId> for Pallet<T> {

libs/test-utils/src/mocks/order_manager.rs

@@ -222,6 +222,7 @@ pub mod pallet {
 			InvestmentProperties<T::AccountId, Currency = CurrencyOf<T>>,
 	{
 		type Amount = BalanceOf<T>;
+		type CurrencyId = CurrencyOf<T>;
 		type Error = DispatchError;
 		type InvestmentId = T::InvestmentId;
 
@@ -233,6 +234,15 @@ pub mod pallet {
 			Self::update_invest_order(investment_id, amount)
 		}
 
+		fn accepted_payment_currency(
+			investment_id: Self::InvestmentId,
+			currency: Self::CurrencyId,
+		) -> bool {
+			T::Accountant::info(investment_id)
+				.map(|info| info.payment_currency() == currency)
+				.unwrap_or(false)
+		}
+
 		fn investment(
 			_: &T::AccountId,
 			investment_id: Self::InvestmentId,
@@ -250,6 +260,15 @@ pub mod pallet {
 			Self::update_redeem_order(investment_id, amount)
 		}
 
+		fn accepted_payout_currency(
+			investment_id: Self::InvestmentId,
+			currency: Self::CurrencyId,
+		) -> bool {
+			T::Accountant::info(investment_id)
+				.map(|info| info.payment_currency() == currency)
+				.unwrap_or(false)
+		}
+
 		fn redemption(
 			_: &T::AccountId,
 			investment_id: Self::InvestmentId,

libs/traits/src/connectors.rs

@@ -0,0 +1,58 @@
+// Copyright 2021 Centrifuge GmbH (centrifuge.io).
+// This file is part of Centrifuge chain project.
+
+// Centrifuge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version (see http://www.gnu.org/licenses).
+
+// Centrifuge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+use codec::Input;
+use frame_support::dispatch::DispatchResult;
+use sp_std::vec::Vec;
+
+/// An encoding & decoding trait for the purpose of meeting the
+/// Connectors General Message Passing Format
+pub trait Codec: Sized {
+	fn serialize(&self) -> Vec<u8>;
+	fn deserialize<I: Input>(input: &mut I) -> Result<Self, codec::Error>;
+}
+
+/// The trait required for processing outbound connectors messages.
+pub trait OutboundQueue {
+	// pub trait OutboundQueue<Sender, Message, Destination> {
+	/// The sender type of the outgoing message.
+	type Sender;
+
+	/// The message type that is processed.
+	type Message;
+
+	/// The destination this message should go to.
+	type Destination;
+
+	/// Submit a message to the outbound queue.
+	fn submit(
+		// destination: Destination,
+		// sender: Sender,
+		// msg: Message,
+		destination: Self::Destination,
+		sender: Self::Sender,
+		msg: Self::Message,
+	) -> DispatchResult;
+}
+
+/// The trait required for processing incoming connectors messages.
+pub trait InboundQueue {
+	/// The sender type of the incoming message.
+	type Sender;
+
+	/// The connector message enum.
+	type Message;
+
+	/// Process a message from the inbound queue.
+	fn process(sender: Self::Sender, msg: Self::Message) -> DispatchResult;
+}

libs/traits/src/lib.rs

@@ -35,14 +35,14 @@ use sp_runtime::{
 };
 use sp_std::{fmt::Debug, hash::Hash, str::FromStr, vec::Vec};
 
-/// Traits related to rewards.
-pub mod rewards;
-
-/// Traits related to data registry & collections.
-pub mod data;
-
 /// Traits related to checked changes.
 pub mod changes;
+/// Traits related to connectors.
+pub mod connectors;
+/// Traits related to data registry and collection.
+pub mod data;
+/// Traits related to rewards.
+pub mod rewards;
 
 /// A trait used for loosely coupling the claim pallet with a reward mechanism.
 ///
@@ -142,6 +142,9 @@ pub trait PoolInspect<AccountId, CurrencyId> {
 
 	/// Get the account used for the given `pool_id`.
 	fn account_for(pool_id: Self::PoolId) -> AccountId;
+
+	// Get the currency used for the given `pool_id`.
+	fn currency_for(pool_id: Self::PoolId) -> Option<CurrencyId>;
 }
 
 /// Variants for valid Pool updates to send out as events
@@ -377,9 +380,10 @@ pub trait TrancheCurrency<PoolId, TrancheId> {
 /// A trait, when implemented allows to invest into
 /// investment classes
 pub trait Investment<AccountId> {
-	type Error: Debug;
-	type InvestmentId;
 	type Amount;
+	type CurrencyId;
+	type Error: Debug;
+	type InvestmentId: Into<Self::CurrencyId>;
 
 	/// Updates the current investment amount of who into the
 	/// investment class to amount.
@@ -391,6 +395,12 @@ pub trait Investment<AccountId> {
 		amount: Self::Amount,
 	) -> Result<(), Self::Error>;
 
+	/// Checks whether a currency can be used for buying `InvestmentId`
+	fn accepted_payment_currency(
+		investment_id: Self::InvestmentId,
+		currency: Self::CurrencyId,
+	) -> bool;
+
 	/// Returns, if possible, the current investment amount of who into the
 	/// given investment class
 	fn investment(
@@ -408,6 +418,12 @@ pub trait Investment<AccountId> {
 		amount: Self::Amount,
 	) -> Result<(), Self::Error>;
 
+	/// Checks whether a currency is accepted as a payout for an `InvestmentId`
+	fn accepted_payout_currency(
+		investment_id: Self::InvestmentId,
+		currency: Self::CurrencyId,
+	) -> bool;
+
 	/// Returns, if possible, the current redemption amount of who into the
 	/// given investment class
 	fn redemption(
@@ -416,6 +432,29 @@ pub trait Investment<AccountId> {
 	) -> Result<Self::Amount, Self::Error>;
 }
 
+/// A trait which allows to collect existing investments and redemptions.
+pub trait InvestmentCollector<AccountId> {
+	type Error: Debug;
+	type InvestmentId;
+	type Result: Debug;
+
+	/// Collect the results of a user's invest orders for the given
+	/// investment. If any amounts are not fulfilled they are directly
+	/// appended to the next active order for this investment.
+	fn collect_investment(
+		who: AccountId,
+		investment_id: Self::InvestmentId,
+	) -> Result<Self::Result, Self::Error>;
+
+	/// Collect the results of a users redeem orders for the given
+	/// investment. If any amounts are not fulfilled they are directly
+	/// appended to the next active order for this investment.
+	fn collect_redemption(
+		who: AccountId,
+		investment_id: Self::InvestmentId,
+	) -> Result<Self::Result, Self::Error>;
+}
+
 /// A trait, when implemented must take care of
 /// collecting orders (invest & redeem) for a given investment class.
 /// When being asked it must return the current orders and
@@ -626,16 +665,24 @@ pub mod fees {
 }
 
 /// Trait to determine whether a sending account and currency have a
-/// restriction, and if so is there an allowance for the reciever location.
+/// restriction, and if so is there an allowance for the receiver location.
 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  `receive` location 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,
-		recieve: Self::Location,
+		receive: Self::Location,
 		currency: Self::CurrencyId,
 	) -> DispatchResult;
 }
+
+/// Trait to retrieve information about currencies.
+pub trait CurrencyInspect {
+	type CurrencyId;
+
+	/// Checks whether the provided currency is a tranche token.
+	fn is_tranche_token(currency: Self::CurrencyId) -> bool;
+}

libs/types/src/domain_address.rs

@@ -10,10 +10,11 @@
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
-use cfg_utils::vec_to_fixed_array;
-use codec::{Decode, Encode, MaxEncodedLen};
+use cfg_traits::connectors::Codec;
+use cfg_utils::{decode_be_bytes, vec_to_fixed_array};
+use codec::{Decode, Encode, Input, MaxEncodedLen};
 use scale_info::TypeInfo;
-use sp_core::TypeId;
+use sp_std::{vec, vec::Vec};
 
 use crate::EVMChainId;
 
@@ -32,15 +33,38 @@ pub enum Domain {
 	EVM(EVMChainId),
 }
 
+impl Codec for Domain {
+	fn serialize(&self) -> Vec<u8> {
+		match self {
+			Self::Centrifuge => vec![0; 9],
+			Self::EVM(chain_id) => {
+				let mut output: Vec<u8> = 1u8.encode();
+				output.append(&mut chain_id.to_be_bytes().to_vec());
+
+				output
+			}
+		}
+	}
+
+	fn deserialize<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let variant = input.read_byte()?;
+
+		match variant {
+			0 => Ok(Self::Centrifuge),
+			1 => {
+				let chain_id = decode_be_bytes::<8, _, _>(input)?;
+				Ok(Self::EVM(chain_id))
+			}
+			_ => Err(codec::Error::from("Unknown Domain variant")),
+		}
+	}
+}
+
 #[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
 pub struct DomainLocator<Domain> {
 	pub domain: Domain,
 }
 
-impl<Domain> TypeId for DomainLocator<Domain> {
-	const TYPE_ID: [u8; 4] = *b"domn";
-}
-
 #[derive(Encode, Decode, Clone, PartialEq, Eq, TypeInfo, MaxEncodedLen)]
 #[cfg_attr(feature = "std", derive(Debug))]
 pub enum DomainAddress {

libs/types/src/ids.rs

@@ -15,7 +15,10 @@
 use frame_support::PalletId;
 use sp_runtime::TypeId;
 
-use crate::investments::InvestmentAccount;
+use crate::{
+	domain_address::{DomainAddress, DomainLocator},
+	investments::InvestmentAccount,
+};
 
 // The TypeId impl we derive pool-accounts from
 impl<InvestmentId> TypeId for InvestmentAccount<InvestmentId> {
@@ -41,3 +44,11 @@ pub const CHAIN_BRIDGE_NATIVE_TOKEN_ID: [u8; 4] = *b"xCFG";
 // Reward related
 /// The identifier of the group eligible to receive block rewards.
 pub const COLLATOR_GROUP_ID: u32 = 1;
+
+impl TypeId for DomainAddress {
+	const TYPE_ID: [u8; 4] = *b"dadr";
+}
+
+impl<Domain> TypeId for DomainLocator<Domain> {
+	const TYPE_ID: [u8; 4] = *b"domn";
+}

libs/types/src/tokens.rs

@@ -88,6 +88,14 @@ impl From<StakingCurrency> for CurrencyId {
 	}
 }
 
+impl cfg_traits::CurrencyInspect for CurrencyId {
+	type CurrencyId = CurrencyId;
+
+	fn is_tranche_token(currency: Self::CurrencyId) -> bool {
+		matches!(currency, CurrencyId::Tranche(_, _))
+	}
+}
+
 /// A general index wrapper for a given currency representation which is the
 /// concatenation of the generic prefix and the identifier of the respective
 /// currency.
@@ -138,6 +146,19 @@ where
 	}
 }
 
+impl<Index, Prefix> From<u128> for GeneralCurrencyIndex<Index, Prefix>
+where
+	Index: From<u128>,
+	Prefix: Get<[u8; 12]>,
+{
+	fn from(value: u128) -> Self {
+		GeneralCurrencyIndex {
+			index: value.into(),
+			_phantom: Default::default(),
+		}
+	}
+}
+
 /// A Currency that is solely used by tranches.
 ///
 /// We distinguish here between the enum variant CurrencyId::Tranche(PoolId,
@@ -253,6 +274,10 @@ impl CrossChainTransferability {
 	pub fn includes_xcm(self) -> bool {
 		matches!(self, Self::Xcm(..) | Self::All(..))
 	}
+
+	pub fn includes_connectors(self) -> bool {
+		matches!(self, Self::Connectors | Self::All(..))
+	}
 }
 
 /// Connectors-wrapped tokens