Connectors v1++

flake.nix

@@ -93,7 +93,7 @@
             };
 
             # This is a hash of all the Cargo dependencies, for reproducibility.
-            cargoSha256 = "sha256-FgnJKi1LfSw+JX/2dx7uXClb3hkdCwoWTefZ83x6Tf4=";
+            cargoSha256 = "sha256-qFvobNDYPRfjHTyfF0KsqBCp+vhls0d8d6BcqKlhiek=";
 
             nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ];
             buildInputs = with pkgs; [ openssl ] ++ (

libs/utils/src/lib.rs

@@ -13,6 +13,7 @@
 // Ensure we're `no_std` when compiling for WebAssembly.
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use codec::{Decode, Encode, Input};
 use sp_std::{cmp::min, vec::Vec};
 
 /// Build a fixed-size array using as many elements from `src` as possible without
@@ -26,13 +27,41 @@ pub fn vec_to_fixed_array<const S: usize>(src: Vec<u8>) -> [u8; S] {
 	dest
 }
 
+/// Encode a value in its big-endian representation of which all we know is that it
+/// implements Encode. We use this for number types to make sure they are encoded
+/// the way they are expected to be decoded on the Solidity side.
+pub fn encode_be(x: impl Encode) -> Vec<u8> {
+	let mut output = x.encode();
+	output.reverse();
+	output
+}
+
+/// Decode a type O by reading S bytes from I. Those bytes are expected to be encoded
+/// as big-endian and thus needs reversing to little-endian before decoding to O.
+pub fn decode_be_bytes<const S: usize, O: Decode, I: Input>(
+	input: &mut I,
+) -> Result<O, codec::Error> {
+	let mut bytes = [0; S];
+	input.read(&mut bytes[..])?;
+	bytes.reverse();
+
+	O::decode(&mut bytes.as_slice())
+}
+
+/// Decode a type 0 by reading S bytes from I.
+pub fn decode<const S: usize, O: Decode, I: Input>(input: &mut I) -> Result<O, codec::Error> {
+	let mut bytes = [0; S];
+	input.read(&mut bytes[..])?;
+
+	O::decode(&mut bytes.as_slice())
+}
+
 /// Function that initializes the frame system & Aura, so a timestamp can be set and pass validation
 #[cfg(any(feature = "runtime-benchmarks", feature = "std"))]
 pub fn set_block_number_timestamp<T>(block_number: T::BlockNumber, timestamp: T::Moment)
 where
 	T: pallet_aura::Config + frame_system::Config + pallet_timestamp::Config,
 {
-	use codec::Encode;
 	use frame_support::traits::Hooks;
 	use sp_consensus_aura::AURA_ENGINE_ID;
 	use sp_runtime::{Digest, DigestItem};

pallets/connectors/src/lib.rs

@@ -14,7 +14,7 @@
 use core::convert::TryFrom;
 
 use cfg_traits::PoolInspect;
-use cfg_utils::vec_to_fixed_array;
+use cfg_utils::{decode_be_bytes, vec_to_fixed_array};
 use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen};
 use frame_support::traits::{
 	fungibles::{Inspect, Mutate, Transfer},
@@ -83,10 +83,7 @@ impl Decode for Domain {
 		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);
+				let chain_id = decode_be_bytes::<8, _, _>(input)?;
 				Ok(Self::EVM(chain_id))
 			}
 			_ => Err(codec::Error::from("Unknown Domain variant")),
@@ -242,12 +239,22 @@ pub mod pallet {
 			domain: Domain,
 			router: Router<CurrencyIdOf<T>>,
 		},
+
+		IncomingMessage {
+			sender: T::AccountId,
+			message: Vec<u8>,
+		},
 	}
 
 	#[pallet::storage]
 	pub(crate) type DomainRouter<T: Config> =
 		StorageMap<_, Blake2_128Concat, Domain, Router<CurrencyIdOf<T>>>;
 
+	/// The set of known connectors. This set is used as an allow-list when authorizing
+	/// the origin of incoming messages through the `handle` extrinsic.
+	#[pallet::storage]
+	pub(crate) type KnownConnectors<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, ()>;
+
 	#[pallet::error]
 	pub enum Error<T> {
 		/// A pool could not be found
@@ -268,6 +275,10 @@ pub mod pallet {
 		UnauthorizedTransfer,
 		/// Failed to build Ethereum_Xcm call
 		FailedToBuildEthereumXcmCall,
+		/// The origin of an incoming message is not in the allow-list
+		InvalidIncomingMessageOrigin,
+		/// Failed to decode an incoming message
+		InvalidIncomingMessage,
 	}
 
 	#[pallet::call]
@@ -287,6 +298,16 @@ pub mod pallet {
 			Ok(())
 		}
 
+		/// Add an AccountId to the set of known connectors, allowing that origin
+		/// to send incoming messages.
+		#[pallet::weight(< T as Config >::WeightInfo::add_connector())]
+		pub fn add_connector(origin: OriginFor<T>, connector: T::AccountId) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+			<KnownConnectors<T>>::insert(connector, ());
+
+			Ok(())
+		}
+
 		/// Add a pool to a given domain
 		#[pallet::weight(< T as Config >::WeightInfo::add_pool())]
 		pub fn add_pool(
@@ -473,6 +494,30 @@ pub mod pallet {
 
 			Ok(())
 		}
+
+		/// Handle an incoming message
+		/// TODO(nuno): we probably need a custom origin type for these messages to ensure they have
+		/// come in through XCM. Probably even handle it in a separate pallet? For now, let's have a
+		/// POC here to test the pipeline Ethereum ---> Moonbeam ---> Centrifuge::connectors
+		#[pallet::call_index(99)]
+		#[pallet::weight(< T as Config >::WeightInfo::handle())]
+		pub fn handle(origin: OriginFor<T>, bytes: Vec<u8>) -> DispatchResult {
+			let sender = ensure_signed(origin.clone())?;
+			ensure!(
+				<KnownConnectors<T>>::contains_key(&sender),
+				Error::<T>::InvalidIncomingMessageOrigin
+			);
+
+			Self::deposit_event(Event::IncomingMessage {
+				sender,
+				message: bytes.clone(),
+			});
+			// todo: do someting with the decoded message later on
+			let _: MessageOf<T> = Message::decode(&mut bytes.as_slice())
+				.map_err(|_| Error::<T>::InvalidIncomingMessage)?;
+
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {