Relay subcommand that performs token RLT <> MLAU token swap

bin/millau/node/src/chain_spec.rs

@@ -135,6 +135,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("George//stash"),
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
 							get_account_id_from_seed::<sr25519::Public>("RialtoMessagesOwner"),
+							get_account_id_from_seed::<sr25519::Public>("WithRialtoTokenSwap"),
 							pallet_bridge_messages::relayer_fund_account_id::<
 								bp_millau::AccountId,
 								bp_millau::AccountIdConverter,

bin/rialto/node/src/chain_spec.rs

@@ -151,6 +151,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("George//stash"),
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
 							get_account_id_from_seed::<sr25519::Public>("MillauMessagesOwner"),
+							get_account_id_from_seed::<sr25519::Public>("WithMillauTokenSwap"),
 							pallet_bridge_messages::relayer_fund_account_id::<
 								bp_rialto::AccountId,
 								bp_rialto::AccountIdConverter,

modules/messages/src/lib.rs

@@ -777,12 +777,11 @@ pub mod pallet {
 /// messages and lanes states proofs.
 pub mod storage_keys {
 	use super::*;
-	use frame_support::StorageHasher;
 	use sp_core::storage::StorageKey;
 
 	/// Storage key of the outbound message in the runtime storage.
 	pub fn message_key(pallet_prefix: &str, lane: &LaneId, nonce: MessageNonce) -> StorageKey {
-		storage_map_final_key(
+		bp_runtime::storage_map_final_key_blake2_128concat(
 			pallet_prefix,
 			"OutboundMessages",
 			&MessageKey { lane_id: *lane, nonce }.encode(),
@@ -791,28 +790,12 @@ pub mod storage_keys {
 
 	/// Storage key of the outbound message lane state in the runtime storage.
 	pub fn outbound_lane_data_key(pallet_prefix: &str, lane: &LaneId) -> StorageKey {
-		storage_map_final_key(pallet_prefix, "OutboundLanes", lane)
+		bp_runtime::storage_map_final_key_blake2_128concat(pallet_prefix, "OutboundLanes", lane)
 	}
 
 	/// Storage key of the inbound message lane state in the runtime storage.
 	pub fn inbound_lane_data_key(pallet_prefix: &str, lane: &LaneId) -> StorageKey {
-		storage_map_final_key(pallet_prefix, "InboundLanes", lane)
-	}
-
-	/// This is a copypaste of the `frame_support::storage::generator::StorageMap::storage_map_final_key`.
-	fn storage_map_final_key(pallet_prefix: &str, map_name: &str, key: &[u8]) -> StorageKey {
-		let pallet_prefix_hashed = frame_support::Twox128::hash(pallet_prefix.as_bytes());
-		let storage_prefix_hashed = frame_support::Twox128::hash(map_name.as_bytes());
-		let key_hashed = frame_support::Blake2_128Concat::hash(key);
-
-		let mut final_key =
-			Vec::with_capacity(pallet_prefix_hashed.len() + storage_prefix_hashed.len() + key_hashed.len());
-
-		final_key.extend_from_slice(&pallet_prefix_hashed[..]);
-		final_key.extend_from_slice(&storage_prefix_hashed[..]);
-		final_key.extend_from_slice(key_hashed.as_ref());
-
-		StorageKey(final_key)
+		bp_runtime::storage_map_final_key_blake2_128concat(pallet_prefix, "InboundLanes", lane)
 	}
 }
 

modules/token-swap/src/lib.rs

@@ -56,12 +56,11 @@ use bp_messages::{
 	DeliveredMessages, LaneId, MessageNonce,
 };
 use bp_runtime::{messages::DispatchFeePayment, ChainId};
-use bp_token_swap::{TokenSwap, TokenSwapType};
-use codec::{Decode, Encode};
+use bp_token_swap::{TokenSwap, TokenSwapState, TokenSwapType};
+use codec::Encode;
 use frame_support::{
 	fail,
 	traits::{Currency, ExistenceRequirement},
-	RuntimeDebug,
 };
 use sp_core::H256;
 use sp_io::hashing::blake2_256;
@@ -71,22 +70,11 @@ use sp_std::vec::Vec;
 #[cfg(test)]
 mod mock;
 
-/// Pending token swap state.
-#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, Eq)]
-pub enum TokenSwapState {
-	/// The swap has been started using the `start_claim` call, but we have no proof that it has
-	/// happened at the Bridged chain.
-	Started,
-	/// The swap has happened at the Bridged chain and may be claimed by the Bridged chain party using
-	/// the `claim_swap` call.
-	Confirmed,
-	/// The swap has failed at the Bridged chain and This chain party may cancel it using the
-	/// `cancel_swap` call.
-	Failed,
-}
-
 pub use pallet::*;
 
+/// Name of the `PendingSwaps` storage map.
+pub const PENDING_SWAPS_MAP_NAME: &str = "PendingSwaps";
+
 // comes from #[pallet::event]
 #[allow(clippy::unused_unit)]
 #[frame_support::pallet]
@@ -324,6 +312,13 @@ pub mod pallet {
 					return sp_runtime::TransactionOutcome::Rollback(Err(Error::<T, I>::SwapAlreadyStarted.into()));
 				}
 
+				log::trace!(
+					target: "runtime::bridge-token-swap",
+					"The swap {:?} (hash {:?}) has been started",
+					swap,
+					swap_hash,
+				);
+
 				// remember that we're waiting for the transfer message delivery confirmation
 				PendingMessages::<T, I>::insert(transfer_message_nonce, swap_hash);
 
@@ -475,14 +470,21 @@ pub mod pallet {
 				reads += 1;
 				if let Some(swap_hash) = PendingMessages::<T, I>::take(message_nonce) {
 					writes += 1;
-					PendingSwaps::<T, I>::insert(
+
+					let token_swap_state = if delivered_messages.message_dispatch_result(message_nonce) {
+						TokenSwapState::Confirmed
+					} else {
+						TokenSwapState::Failed
+					};
+
+					log::trace!(
+						target: "runtime::bridge-token-swap",
+						"The dispatch of swap {:?} has been completed with {:?} status",
 						swap_hash,
-						if delivered_messages.message_dispatch_result(message_nonce) {
-							TokenSwapState::Confirmed
-						} else {
-							TokenSwapState::Failed
-						},
+						token_swap_state,
 					);
+
+					PendingSwaps::<T, I>::insert(swap_hash, token_swap_state);
 				}
 			}
 
@@ -534,6 +536,18 @@ pub mod pallet {
 				));
 			}
 
+			log::trace!(
+				target: "runtime::bridge-token-swap",
+				"The swap {:?} (hash {:?}) has been completed with {} status",
+				swap,
+				swap_hash,
+				match event {
+					Event::SwapClaimed(_) => "claimed",
+					Event::SwapCancelled(_) => "cancelled",
+					_ => "<unknown>",
+				},
+			);
+
 			// forget about swap
 			PendingSwaps::<T, I>::remove(swap_hash);
 

primitives/chain-millau/src/lib.rs

@@ -258,6 +258,8 @@ pub fn max_extrinsic_size() -> u32 {
 
 /// Name of the With-Rialto messages pallet instance in the Millau runtime.
 pub const WITH_RIALTO_MESSAGES_PALLET_NAME: &str = "BridgeRialtoMessages";
+/// Name of the With-Rialto token swap pallet instance in the Millau runtime.
+pub const WITH_RIALTO_TOKEN_SWAP_PALLET_NAME: &str = "BridgeRialtoTokenSwap";
 
 /// Name of the `MillauFinalityApi::best_finalized` runtime method.
 pub const BEST_FINALIZED_MILLAU_HEADER_METHOD: &str = "MillauFinalityApi_best_finalized";

primitives/runtime/src/lib.rs

@@ -19,7 +19,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use codec::Encode;
-use frame_support::RuntimeDebug;
+use frame_support::{RuntimeDebug, StorageHasher};
 use sp_core::{hash::H256, storage::StorageKey};
 use sp_io::hashing::blake2_256;
 use sp_std::{convert::TryFrom, vec::Vec};
@@ -184,6 +184,33 @@ impl<BlockNumber: Copy + Into<u64>, BlockHash: Copy> TransactionEra<BlockNumber,
 	}
 }
 
+/// This is a copypaste of the `frame_support::storage::generator::StorageMap::storage_map_final_key`
+/// for `Blake2_128Concat` maps.
+///
+/// We're using it because to call `storage_map_final_key` directly, we need access to the runtime
+/// and pallet instance, which (sometimes) is impossible.
+pub fn storage_map_final_key_blake2_128concat(pallet_prefix: &str, map_name: &str, key: &[u8]) -> StorageKey {
+	storage_map_final_key_identity(pallet_prefix, map_name, &frame_support::Blake2_128Concat::hash(key))
+}
+
+/// This is a copypaste of the `frame_support::storage::generator::StorageMap::storage_map_final_key`
+/// for `Identity` maps.
+///
+/// We're using it because to call `storage_map_final_key` directly, we need access to the runtime
+/// and pallet instance, which (sometimes) is impossible.
+pub fn storage_map_final_key_identity(pallet_prefix: &str, map_name: &str, key_hashed: &[u8]) -> StorageKey {
+	let pallet_prefix_hashed = frame_support::Twox128::hash(pallet_prefix.as_bytes());
+	let storage_prefix_hashed = frame_support::Twox128::hash(map_name.as_bytes());
+
+	let mut final_key = Vec::with_capacity(pallet_prefix_hashed.len() + storage_prefix_hashed.len() + key_hashed.len());
+
+	final_key.extend_from_slice(&pallet_prefix_hashed[..]);
+	final_key.extend_from_slice(&storage_prefix_hashed[..]);
+	final_key.extend_from_slice(key_hashed.as_ref());
+
+	StorageKey(final_key)
+}
+
 /// This is how a storage key of storage parameter (`parameter_types! { storage Param: bool = false; }`) is computed.
 ///
 /// Copypaste from `frame_support::parameter_types` macro

primitives/token-swap/src/lib.rs

@@ -20,6 +20,20 @@ use codec::{Decode, Encode};
 use frame_support::RuntimeDebug;
 use sp_core::U256;
 
+/// Pending token swap state.
+#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, Eq)]
+pub enum TokenSwapState {
+	/// The swap has been started using the `start_claim` call, but we have no proof that it has
+	/// happened at the Bridged chain.
+	Started,
+	/// The swap has happened at the Bridged chain and may be claimed by the Bridged chain party using
+	/// the `claim_swap` call.
+	Confirmed,
+	/// The swap has failed at the Bridged chain and This chain party may cancel it using the
+	/// `cancel_swap` call.
+	Failed,
+}
+
 /// Token swap type.
 ///
 /// Different swap types give a different guarantees regarding possible swap

relays/bin-substrate/Cargo.toml

@@ -15,6 +15,7 @@ log = "0.4.14"
 num-format = "0.4"
 num-traits = "0.2"
 paste = "1.0"
+rand = "0.8"
 structopt = "0.3"
 strum = { version = "0.21.0", features = ["derive"] }
 
@@ -28,14 +29,17 @@ bp-millau = { path = "../../primitives/chain-millau" }
 bp-polkadot = { path = "../../primitives/chain-polkadot" }
 bp-rialto = { path = "../../primitives/chain-rialto" }
 bp-rococo = { path = "../../primitives/chain-rococo" }
+bp-token-swap = { path = "../../primitives/token-swap" }
 bp-wococo = { path = "../../primitives/chain-wococo" }
 bp-runtime = { path = "../../primitives/runtime" }
 bp-westend = { path = "../../primitives/chain-westend" }
 bridge-runtime-common = { path = "../../bin/runtime-common" }
 finality-relay = { path = "../finality" }
 messages-relay = { path = "../messages" }
 millau-runtime = { path = "../../bin/millau/runtime" }
+pallet-bridge-dispatch = { path = "../../modules/dispatch" }
 pallet-bridge-messages = { path = "../../modules/messages" }
+pallet-bridge-token-swap = { path = "../../modules/token-swap" }
 relay-kusama-client = { path = "../client-kusama" }
 relay-millau-client = { path = "../client-millau" }
 relay-polkadot-client = { path = "../client-polkadot" }
@@ -51,6 +55,7 @@ substrate-relay-helper = { path = "../lib-substrate-relay" }
 # Substrate Dependencies
 
 frame-support = { git = "https://github.com/paritytech/substrate", branch = "master" }
+pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }

relays/bin-substrate/src/cli/mod.rs

@@ -36,6 +36,7 @@ mod relay_headers;
 mod relay_headers_and_messages;
 mod relay_messages;
 mod resubmit_transactions;
+mod swap_tokens;
 
 /// Parse relay CLI args.
 pub fn parse_args() -> Command {
@@ -89,6 +90,8 @@ pub enum Command {
 	DeriveAccount(derive_account::DeriveAccount),
 	/// Resubmit transactions with increased tip if they are stalled.
 	ResubmitTransactions(resubmit_transactions::ResubmitTransactions),
+	/// Swap tokens using token-swap bridge.
+	SwapTokens(swap_tokens::SwapTokens),
 }
 
 impl Command {
@@ -120,6 +123,7 @@ impl Command {
 			Self::EstimateFee(arg) => arg.run().await?,
 			Self::DeriveAccount(arg) => arg.run().await?,
 			Self::ResubmitTransactions(arg) => arg.run().await?,
+			Self::SwapTokens(arg) => arg.run().await?,
 		}
 		Ok(())
 	}