Connectors v0.1.0

pallets/connectors/src/lib.rs

@@ -15,7 +15,7 @@ use core::convert::TryFrom;
 
 use cfg_traits::PoolInspect;
 use cfg_utils::vec_to_fixed_array;
-use codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen};
 use frame_support::traits::{
 	fungibles::{Inspect, Mutate, Transfer},
 	OriginTrait,
@@ -25,7 +25,7 @@ pub use pallet::*;
 use scale_info::TypeInfo;
 use sp_core::{TypeId, U256};
 use sp_runtime::{traits::AtLeast32BitUnsigned, FixedPointNumber};
-use sp_std::{boxed::Box, convert::TryInto, vec::Vec};
+use sp_std::{boxed::Box, convert::TryInto, vec, vec::Vec};
 pub mod weights;
 
 mod message;
@@ -45,24 +45,60 @@ pub enum ParachainId {
 	Moonbeam,
 }
 
-/// The EVM chain ID
-/// The type should accomodate all chain ids listed on https://chainlist.org/.
-type EVMChainId = u64;
-
 /// 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
 /// need to pass the Centrifuge domain to send tranche tokens from the other
 /// domain here. Therefore, DO NOT remove or move variants around.
-#[derive(Encode, Decode, Clone, PartialEq, Eq, TypeInfo, MaxEncodedLen)]
+#[derive(Clone, PartialEq, Eq, TypeInfo, MaxEncodedLen)]
 #[cfg_attr(feature = "std", derive(Debug))]
 pub enum Domain {
+	/// Referring to the Centrifuge Parachain. Will be used for handling incoming messages.
+	/// NOTE: Connectors messages CAN NOT be sent directly from the Centrifuge chain to the
+	/// Centrifuge chain itself.
+	Centrifuge,
 	/// An EVM domain, identified by its EVM Chain Id
 	EVM(EVMChainId),
-	/// A Polkadot Parachain domain
-	Parachain(ParachainId),
 }
 
-#[derive(Encode, Decode, Clone, PartialEq, Eq, TypeInfo)]
+impl Encode for Domain {
+	fn encode(&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
+			}
+		}
+	}
+}
+
+impl EncodeLike for Domain {}
+
+impl Decode for Domain {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let variant = input.read_byte()?;
+
+		match variant {
+			0 => Ok(Self::Centrifuge),
+			1 => {
+				let mut chain_id_be_bytes = [0; 8];
+				input.read(&mut chain_id_be_bytes[..])?;
+
+				let chain_id = EVMChainId::from_be_bytes(chain_id_be_bytes);
+				Ok(Self::EVM(chain_id))
+			}
+			_ => Err(codec::Error::from("Unknown Domain variant")),
+		}
+	}
+}
+
+/// The EVM Chain ID
+/// The type should accomodate all chain ids listed on https://chainlist.org/.
+type EVMChainId = u64;
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
 pub struct DomainLocator<Domain> {
 	pub domain: Domain,
 }
@@ -71,14 +107,40 @@ impl<Domain> TypeId for DomainLocator<Domain> {
 	const TYPE_ID: [u8; 4] = *b"domn";
 }
 
-#[derive(Encode, Decode, Default, Clone, PartialEq, Eq, TypeInfo)]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, TypeInfo)]
 #[cfg_attr(feature = "std", derive(Debug))]
-pub struct DomainAddress<Domain> {
-	pub domain: Domain,
-	pub address: [u8; 32],
+pub enum DomainAddress {
+	/// A Centrifuge-Chain based account address, 32-bytes long
+	Centrifuge([u8; 32]),
+	/// An EVM chain address, 20-bytes long
+	EVM(EVMChainId, [u8; 20]),
+}
+
+impl From<DomainAddress> for Domain {
+	fn from(x: DomainAddress) -> Self {
+		match x {
+			DomainAddress::Centrifuge(_) => Domain::Centrifuge,
+			DomainAddress::EVM(chain_id, _) => Domain::EVM(chain_id),
+		}
+	}
+}
+
+impl DomainAddress {
+	/// Get the address in a 32-byte long representation.
+	/// For EVM addresses, append 12 zeros.
+	fn address(&self) -> [u8; 32] {
+		match self.clone() {
+			Self::Centrifuge(x) => x,
+			Self::EVM(_, x) => vec_to_fixed_array(x.to_vec()),
+		}
+	}
+
+	fn domain(&self) -> Domain {
+		self.clone().into()
+	}
 }
 
-impl<Domain> TypeId for DomainAddress<Domain> {
+impl TypeId for DomainAddress {
 	const TYPE_ID: [u8; 4] = *b"dadr";
 }
 
@@ -265,6 +327,9 @@ pub mod pallet {
 				.ok_or(Error::<T>::TrancheMetadataNotFound)?;
 			let token_name = vec_to_fixed_array(metadata.name);
 			let token_symbol = vec_to_fixed_array(metadata.symbol);
+			let price = T::PoolInspect::get_tranche_token_price(pool_id, tranche_id)
+				.ok_or(Error::<T>::MissingTranchePrice)?
+				.price;
 
 			// Send the message to the domain
 			Self::do_send_message(
@@ -274,6 +339,7 @@ pub mod pallet {
 					tranche_id,
 					token_name,
 					token_symbol,
+					price,
 				},
 				domain,
 			)?;
@@ -291,15 +357,16 @@ pub mod pallet {
 		) -> DispatchResult {
 			let who = ensure_signed(origin.clone())?;
 
-			let latest_price = T::PoolInspect::get_tranche_token_price(pool_id, tranche_id)
-				.ok_or(Error::<T>::MissingTranchePrice)?;
+			let price = T::PoolInspect::get_tranche_token_price(pool_id, tranche_id)
+				.ok_or(Error::<T>::MissingTranchePrice)?
+				.price;
 
 			Self::do_send_message(
 				who,
 				Message::UpdateTokenPrice {
 					pool_id,
 					tranche_id,
-					price: latest_price.price,
+					price,
 				},
 				domain,
 			)?;
@@ -311,7 +378,7 @@ pub mod pallet {
 		#[pallet::weight(< T as Config >::WeightInfo::update_member())]
 		pub fn update_member(
 			origin: OriginFor<T>,
-			address: DomainAddress<Domain>,
+			domain_address: DomainAddress,
 			pool_id: PoolIdOf<T>,
 			tranche_id: TrancheIdOf<T>,
 			valid_until: Moment,
@@ -328,22 +395,30 @@ pub mod pallet {
 				BadOrigin
 			);
 
-			// Now add the destination address as a TrancheInvestor of the given tranche
-			T::Permission::add(
+			// Now add the destination address as a TrancheInvestor of the given tranche if
+			// not already one. This check is necessary shall a user have called `update_member`
+			// already but the call has failed on the EVM side and needs to be retried.
+			if !T::Permission::has(
 				PermissionScope::Pool(pool_id),
-				address.into_account_truncating(),
+				domain_address.into_account_truncating(),
 				Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, valid_until)),
-			)?;
+			) {
+				T::Permission::add(
+					PermissionScope::Pool(pool_id),
+					domain_address.into_account_truncating(),
+					Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, valid_until)),
+				)?;
+			}
 
 			Self::do_send_message(
 				who,
 				Message::UpdateMember {
 					pool_id,
 					tranche_id,
 					valid_until,
-					address: address.address,
+					address: domain_address.address(),
 				},
-				address.domain,
+				domain_address.domain(),
 			)?;
 
 			Ok(())
@@ -355,7 +430,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			pool_id: PoolIdOf<T>,
 			tranche_id: TrancheIdOf<T>,
-			address: DomainAddress<Domain>,
+			domain_address: DomainAddress,
 			amount: <T as pallet::Config>::Balance,
 		) -> DispatchResult {
 			let who = ensure_signed(origin.clone())?;
@@ -364,7 +439,7 @@ pub mod pallet {
 			ensure!(
 				T::Permission::has(
 					PermissionScope::Pool(pool_id),
-					address.into_account_truncating(),
+					domain_address.into_account_truncating(),
 					Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, Self::now()))
 				),
 				Error::<T>::UnauthorizedTransfer
@@ -376,8 +451,8 @@ pub mod pallet {
 			T::Tokens::transfer(
 				T::TrancheCurrency::generate(pool_id, tranche_id).into(),
 				&who,
-				&DomainLocator {
-					domain: address.domain.clone(),
+				&DomainLocator::<Domain> {
+					domain: domain_address.domain(),
 				}
 				.into_account_truncating(),
 				amount,
@@ -390,10 +465,10 @@ pub mod pallet {
 					pool_id,
 					tranche_id,
 					amount,
-					domain: address.clone().domain,
-					destination: address.clone().address,
+					domain: domain_address.domain(),
+					address: domain_address.address(),
 				},
-				address.domain,
+				domain_address.domain(),
 			)?;
 
 			Ok(())
@@ -432,8 +507,9 @@ pub mod pallet {
 				ethereum_xcm_call,
 				OriginKind::SovereignAccount,
 				TransactWeights {
-					// Specify a conservative max weight
-					transact_required_weight_at_most: 8_000_000_000,
+					// Convert the max gas_limit into a max transact weight following Moonbeam's formula.
+					transact_required_weight_at_most: xcm_domain.max_gas_limit * 25_000
+						+ 100_000_000,
 					overall_weight: None,
 				},
 			)?;
@@ -464,7 +540,7 @@ pub mod pallet {
 			encoded.append(
 				&mut xcm_primitives::EthereumXcmTransaction::V1(
 					xcm_primitives::EthereumXcmTransactionV1 {
-						gas_limit: U256::from(80_000),
+						gas_limit: U256::from(xcm_domain.max_gas_limit),
 						fee_payment: xcm_primitives::EthereumXcmFee::Auto,
 						action: pallet_ethereum::TransactionAction::Call(
 							xcm_domain.contract_address,
@@ -485,3 +561,50 @@ pub mod pallet {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use cfg_primitives::AccountId;
+	use codec::{Decode, Encode};
+	use sp_runtime::traits::AccountIdConversion;
+
+	use super::DomainAddress;
+	use crate::Domain;
+
+	#[test]
+	fn test_domain_encode_decode() {
+		test_domain_identity(Domain::Centrifuge);
+		test_domain_identity(Domain::EVM(1284));
+		test_domain_identity(Domain::EVM(1));
+	}
+
+	/// Test that decode . encode results in the original value
+	fn test_domain_identity(domain: Domain) {
+		let encoded = domain.encode();
+		let decoded: Domain = Domain::decode(&mut encoded.as_slice()).expect("");
+
+		assert_eq!(domain, decoded);
+	}
+
+	#[test]
+	fn domain_address_account_derivation() {
+		assert_eq!(
+			account_from(DomainAddress::EVM(1284, [9; 20])),
+			account_from(DomainAddress::EVM(1284, [9; 20])),
+		);
+
+		assert_ne!(
+			account_from(DomainAddress::EVM(1284, [42; 20])),
+			account_from(DomainAddress::EVM(1284, [24; 20])),
+		);
+
+		assert_ne!(
+			account_from(DomainAddress::EVM(1284, [9; 20])),
+			account_from(DomainAddress::EVM(1285, [9; 20])),
+		);
+	}
+
+	fn account_from(domain_address: DomainAddress) -> AccountId {
+		domain_address.into_account_truncating()
+	}
+}