Bidirectional token transfer (#740)

* Transfer from parachain to ethereum

Use ChainSafe's solution to support cross-chain transfers from parachains to ether

* integration tests

* launch scripts

* build chainBridge

* give execution permission

* build chainBridge

* new test script

* integration test compatible with docker

* create dir if not exist

* build docker image

* change log path

* update filterMode

* remove useless code

* adjust code

* add README.md

* adjust code

* give execution permission

* remove license comment

* update scripts

Author: zhizming-zhong

.gitignore

@@ -15,3 +15,5 @@ ts-tests/package-lock.json
 tags.lock
 
 recipe.json
+
+gethdata

Makefile

@@ -82,6 +82,9 @@ build-node-tryruntime:
 	cargo build --locked --features try-runtime --release
 
 # launch a local network
+.PHONY: launch-docker-bridge
+launch-docker-bridge:
+	@./scripts/launch-local-bridge-docker.sh
 
 .PHONY: launch-docker-litentry ## Launch a local litentry-parachain network with docker
 launch-docker-litentry: generate-docker-compose-litentry
@@ -99,19 +102,23 @@ launch-binary-litentry:
 launch-binary-litmus:
 	@./scripts/launch-local-binary.sh litmus
 
+.PHONY: launch-binary-rococo ## Launch a local rococo-parachain network with binaries
+launch-binary-rococo:
+	@./scripts/launch-local-binary.sh rococo
+
 # run tests
 
 .PHONY: test-cargo-all ## cargo test --all
 test-cargo-all:
 	@cargo test --release --all
 
 .PHONY: test-ts-docker-litentry ## Run litentry ts tests with docker without clean-up
-test-ts-docker-litentry: launch-docker-litentry
-	@./scripts/run-ts-test.sh
+test-ts-docker-litentry: launch-docker-litentry launch-docker-bridge
+	@./scripts/run-ts-test.sh bridge
 
 .PHONY: test-ts-docker-litmus ## Run litmus ts tests with docker without clean-up
-test-ts-docker-litmus: launch-docker-litmus
-	@./scripts/run-ts-test.sh
+test-ts-docker-litmus: launch-docker-litmus launch-docker-bridge
+	@./scripts/run-ts-test.sh bridge
 
 .PHONY: test-ts-binary-litentry ## Run litentry ts tests with binary without clean-up
 test-ts-binary-litentry: launch-binary-litentry

docker/bridge.dockerfile

@@ -0,0 +1,3 @@
+FROM golang:1.18
+
+RUN go install github.com/litentry/ChainBridge/cmd/chainbridge@dev

pallets/bridge-transfer/src/lib.rs

@@ -17,13 +17,13 @@
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub use pallet::*;
+
 #[cfg(test)]
 mod mock;
 #[cfg(test)]
 mod tests;
 
-pub use pallet::*;
-
 #[frame_support::pallet]
 pub mod pallet {
 	use frame_support::{
@@ -32,6 +32,7 @@ pub mod pallet {
 	};
 	use frame_system::pallet_prelude::*;
 	use sp_runtime::traits::CheckedAdd;
+	use sp_std::vec::Vec;
 
 	pub use pallet_bridge as bridge;
 
@@ -68,7 +69,6 @@ pub mod pallet {
 	}
 
 	#[pallet::event]
-	// #[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {}
 
 	#[pallet::error]
@@ -92,6 +92,20 @@ pub mod pallet {
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
+		/// Transfers some amount of the native token to some recipient on a (whitelisted)
+		/// destination chain.
+		#[pallet::weight(195_000_000)]
+		pub fn transfer_native(
+			origin: OriginFor<T>,
+			amount: bridge::BalanceOf<T>,
+			recipient: Vec<u8>,
+			dest_id: bridge::BridgeChainId,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			let resource_id = T::NativeTokenResourceId::get();
+			<bridge::Pallet<T>>::transfer_fungible(source, dest_id, resource_id, recipient, amount)
+		}
+
 		/// Executes a simple currency transfer using the bridge account as the source
 		#[pallet::weight(195_000_000)]
 		pub fn transfer(

pallets/bridge-transfer/src/mock.rs

@@ -101,14 +101,17 @@ impl pallet_balances::Config for Test {
 parameter_types! {
 	pub const TestChainId: u8 = 5;
 	pub const ProposalLifetime: u64 = 100;
+	pub const TreasuryAccount:u64 = 0x8;
 }
 
 impl bridge::Config for Test {
 	type Event = Event;
 	type BridgeCommitteeOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type Proposal = Call;
 	type BridgeChainId = TestChainId;
+	type Currency = Balances;
 	type ProposalLifetime = ProposalLifetime;
+	type TreasuryAccount = TreasuryAccount;
 }
 
 parameter_types! {
@@ -151,7 +154,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	.assimilate_storage(&mut t)
 	.unwrap();
 	let mut ext = sp_io::TestExternalities::new(t);
-	ext.execute_with(|| System::set_block_number(1));
+	ext.execute_with(|| frame_system::Pallet::<Test>::set_block_number(1));
 	ext
 }
 

pallets/bridge-transfer/src/tests.rs

@@ -20,8 +20,8 @@ use super::{
 	bridge,
 	mock::{
 		assert_events, balances, new_test_ext, Balances, Bridge, BridgeTransfer, Call, Event,
-		NativeTokenResourceId, Origin, ProposalLifetime, Test, ENDOWED_BALANCE, MAXIMUM_ISSURANCE,
-		RELAYER_A, RELAYER_B, RELAYER_C,
+		NativeTokenResourceId, Origin, ProposalLifetime, Test, TreasuryAccount, ENDOWED_BALANCE,
+		MAXIMUM_ISSURANCE, RELAYER_A, RELAYER_B, RELAYER_C,
 	},
 	*,
 };
@@ -68,6 +68,35 @@ fn transfer() {
 	})
 }
 
+#[test]
+fn transfer_native() {
+	new_test_ext().execute_with(|| {
+		let dest_bridge_id: bridge::BridgeChainId = 0;
+		let resource_id = NativeTokenResourceId::get();
+		let dest_account: Vec<u8> = vec![1];
+		assert_ok!(pallet_bridge::Pallet::<Test>::update_fee(Origin::root(), dest_bridge_id, 10));
+		assert_ok!(pallet_bridge::Pallet::<Test>::whitelist_chain(Origin::root(), dest_bridge_id));
+		assert_ok!(Pallet::<Test>::transfer_native(
+			Origin::signed(RELAYER_A),
+			100,
+			dest_account.clone(),
+			dest_bridge_id
+		));
+		assert_eq!(pallet_balances::Pallet::<Test>::free_balance(&TreasuryAccount::get()), 10);
+		assert_eq!(
+			pallet_balances::Pallet::<Test>::free_balance(&RELAYER_A),
+			ENDOWED_BALANCE - 100
+		);
+		assert_events(vec![Event::Bridge(bridge::Event::FungibleTransfer(
+			dest_bridge_id,
+			1,
+			resource_id,
+			100 - 10,
+			dest_account,
+		))]);
+	})
+}
+
 #[test]
 fn mint_overflow() {
 	new_test_ext().execute_with(|| {

pallets/bridge/src/lib.rs

@@ -28,6 +28,7 @@ pub use pallet::*;
 #[frame_support::pallet]
 pub mod pallet {
 	use codec::{Decode, Encode, EncodeLike};
+	use frame_support::traits::{Currency, ExistenceRequirement::AllowDeath, WithdrawReasons};
 	pub use frame_support::{
 		pallet_prelude::*, traits::StorageVersion, weights::GetDispatchInfo, PalletId, Parameter,
 	};
@@ -36,10 +37,9 @@ pub mod pallet {
 		{self as system},
 	};
 	use scale_info::TypeInfo;
-	pub use sp_core::U256;
 	use sp_runtime::{
 		traits::{AccountIdConversion, Dispatchable},
-		RuntimeDebug,
+		RuntimeDebug, SaturatedConversion,
 	};
 	use sp_std::prelude::*;
 
@@ -49,6 +49,8 @@ pub mod pallet {
 	pub type BridgeChainId = u8;
 	pub type DepositNonce = u64;
 	pub type ResourceId = [u8; 32];
+	pub type BalanceOf<T> =
+		<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
 
 	/// Helper function to concatenate a chain ID and some bytes to produce a resource ID.
 	/// The common format is (31 bytes unique ID + 1 byte chain ID).
@@ -83,7 +85,7 @@ pub mod pallet {
 
 	#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo)]
 	pub enum BridgeEvent {
-		FungibleTransfer(BridgeChainId, DepositNonce, ResourceId, U256, Vec<u8>),
+		FungibleTransfer(BridgeChainId, DepositNonce, ResourceId, u128, Vec<u8>),
 		NonFungibleTransfer(BridgeChainId, DepositNonce, ResourceId, Vec<u8>, Vec<u8>, Vec<u8>),
 		GenericTransfer(BridgeChainId, DepositNonce, ResourceId, Vec<u8>),
 	}
@@ -154,8 +156,14 @@ pub mod pallet {
 		#[pallet::constant]
 		type BridgeChainId: Get<BridgeChainId>;
 
+		/// Currency impl
+		type Currency: Currency<Self::AccountId>;
+
 		#[pallet::constant]
 		type ProposalLifetime: Get<Self::BlockNumber>;
+
+		/// Treasury account to receive assets fee
+		type TreasuryAccount: Get<Self::AccountId>;
 	}
 
 	#[pallet::event]
@@ -171,7 +179,7 @@ pub mod pallet {
 		RelayerRemoved(T::AccountId),
 		/// FungibleTransfer is for relaying fungibles (dest_id, nonce, resource_id, amount,
 		/// recipient)
-		FungibleTransfer(BridgeChainId, DepositNonce, ResourceId, U256, Vec<u8>),
+		FungibleTransfer(BridgeChainId, DepositNonce, ResourceId, u128, Vec<u8>),
 		/// NonFungibleTransfer is for relaying NFTs (dest_id, nonce, resource_id, token_id,
 		/// recipient, metadata)
 		NonFungibleTransfer(BridgeChainId, DepositNonce, ResourceId, Vec<u8>, Vec<u8>, Vec<u8>),
@@ -189,6 +197,8 @@ pub mod pallet {
 		ProposalSucceeded(BridgeChainId, DepositNonce),
 		/// Execution of call failed
 		ProposalFailed(BridgeChainId, DepositNonce),
+		/// Update bridge transfer fee
+		FeeUpdated { dest_id: BridgeChainId, fee: BalanceOf<T> },
 	}
 
 	#[pallet::error]
@@ -223,6 +233,16 @@ pub mod pallet {
 		ProposalAlreadyComplete,
 		/// Lifetime of proposal has been exceeded
 		ProposalExpired,
+		/// Too expensive fee for withdrawn asset
+		FeeTooExpensive,
+		/// No fee with the ID was found
+		FeeDoesNotExist,
+		/// Balance too low to withdraw
+		InsufficientBalance,
+
+		CannotPayAsFee,
+
+		NonceOverFlow,
 	}
 
 	#[pallet::storage]
@@ -261,10 +281,17 @@ pub mod pallet {
 	#[pallet::getter(fn resources)]
 	pub type Resources<T> = StorageMap<_, Blake2_256, ResourceId, Vec<u8>>;
 
+	// ChainBridge Service(https://github.com/litentry/ChainBridge) read this storage for each block,
+	// and if this storage has value, it will perform cross-chain transfer.
+	// For more details, see at: https://github.com/litentry/ChainBridge/blob/main/chains/substrate/listener.go#L186-L237
 	#[pallet::storage]
 	#[pallet::getter(fn bridge_events)]
 	pub type BridgeEvents<T> = StorageValue<_, Vec<BridgeEvent>, ValueQuery>;
 
+	#[pallet::storage]
+	#[pallet::getter(fn bridge_fee)]
+	pub type BridgeFee<T: Config> = StorageMap<_, Twox64Concat, BridgeChainId, BalanceOf<T>>;
+
 	#[pallet::hooks]
 	impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {
 		fn on_initialize(_n: T::BlockNumber) -> Weight {
@@ -352,6 +379,23 @@ pub mod pallet {
 			Self::unregister_relayer(v)
 		}
 
+		/// Change extra bridge transfer fee that user should pay
+		///
+		/// # <weight>
+		/// - O(1) lookup and insert
+		/// # </weight>
+		#[pallet::weight(195_000_000)]
+		pub fn update_fee(
+			origin: OriginFor<T>,
+			dest_id: BridgeChainId,
+			fee: BalanceOf<T>,
+		) -> DispatchResult {
+			T::BridgeCommitteeOrigin::ensure_origin(origin)?;
+			BridgeFee::<T>::insert(dest_id, fee);
+			Self::deposit_event(Event::FeeUpdated { dest_id, fee });
+			Ok(())
+		}
+
 		/// Commits a vote in favour of the provided proposal.
 		///
 		/// If a proposal with the given nonce and source chain ID does not already exist, it will
@@ -448,6 +492,16 @@ pub mod pallet {
 			Self::chains(id).is_some()
 		}
 
+		/// Increments the deposit nonce for the specified chain ID
+		fn bump_nonce(id: BridgeChainId) -> Result<DepositNonce, Error<T>> {
+			let nonce = Self::chains(id).unwrap_or_default();
+			let new_nonce = nonce.checked_add(1u64).ok_or(Error::<T>::NonceOverFlow);
+			if new_nonce.is_ok() {
+				ChainNonces::<T>::insert(id, new_nonce.as_ref().unwrap());
+			}
+			new_nonce
+		}
+
 		// *** Admin methods ***
 
 		/// Set a new voting threshold
@@ -603,6 +657,50 @@ pub mod pallet {
 			Self::deposit_event(Event::ProposalRejected(src_id, nonce));
 			Ok(())
 		}
+
+		/// Initiates a transfer of a fungible asset out of the chain. This should be called by
+		/// another pallet.
+		pub fn transfer_fungible(
+			sender: T::AccountId,
+			dest_id: BridgeChainId,
+			resource_id: ResourceId,
+			to: Vec<u8>,
+			amount: BalanceOf<T>,
+		) -> DispatchResult {
+			ensure!(Self::chain_whitelisted(dest_id), Error::<T>::ChainNotWhitelisted);
+			let fee: BalanceOf<T> =
+				BridgeFee::<T>::get(dest_id).ok_or(Error::<T>::CannotPayAsFee)?;
+			// No need to transfer to to dest chains if it's not enough to pay fee.
+			ensure!(amount > fee, Error::<T>::FeeTooExpensive);
+
+			let actual_amount = amount - fee;
+			// Ensure we have sufficient free balance
+			let balance: BalanceOf<T> = T::Currency::free_balance(&sender);
+			ensure!(balance >= amount, Error::<T>::InsufficientBalance);
+
+			T::Currency::withdraw(&sender, actual_amount, WithdrawReasons::TRANSFER, AllowDeath)?;
+			T::Currency::burn(actual_amount);
+
+			// transfer fee to treasury
+			T::Currency::transfer(&sender, &T::TreasuryAccount::get(), fee, AllowDeath)?;
+
+			let nonce = Self::bump_nonce(dest_id)?;
+			BridgeEvents::<T>::append(BridgeEvent::FungibleTransfer(
+				dest_id,
+				nonce,
+				resource_id,
+				actual_amount.saturated_into::<u128>(),
+				to.clone(),
+			));
+			Self::deposit_event(Event::FungibleTransfer(
+				dest_id,
+				nonce,
+				resource_id,
+				actual_amount.saturated_into::<u128>(),
+				to,
+			));
+			Ok(())
+		}
 	}
 
 	/// Simple ensure origin for the bridge account