Claim funds on Substrate chain by providing proof of funds locking on PoA chain (#91)

* ethereum exchange module

* continue

* continue

* added tests for exchange module

* moved

* remove println

* move again

* fixes

* removed redundant deps

* cargo fmt

* fund_locks_transaction_decode_works

* cargo fmt --all

* fix error processing

* added some tracing to bridge modules

* more tests

* more tests

* cargo fmt --all

* kovan.rs -> exchange.rs

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* added assumption doc

* Airdrop -> DepositInto

* AsIs -> Identity

* OnTransactionSubmitted

* Transfers::Key = Id

* typo

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* block+tx+proof -> proof { block, tx, proof }

* cargo fmt --all

* docs

* check <-> verify

* parse hex

* extracted exchange primitives to separate crate

* added docs to runtime::exchange module

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* typo

* Update modules/currency-exchange/Cargo.toml

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* add docs to currency-exchange module

* change tests names

* cargo fmt --all

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update bin/node/runtime/src/exchange.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* fixed verify_transaction_finalized for siblings of finalized blocks

* cargo fmt --all

* added double spend note

* cargo fmt --all

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>
Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

bridges/modules/currency-exchange/Cargo.toml

@@ -0,0 +1,58 @@
+[package]
+name = "pallet-bridge-currency-exchange"
+description = "A Substrate Runtime module that accepts 'lock funds' transactions from a peer chain and grants an equivalent amount to a the appropriate Substrate account."
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+
+[dependencies]
+serde = { version = "1.0", optional = true }
+codec = { package = "parity-scale-codec", version = "1.0.0", default-features = false }
+sp-currency-exchange = { path = "../../primitives/currency-exchange", default-features = false }
+
+# Substrate Based Dependencies
+[dependencies.frame-support]
+version = "2.0.0-rc1"
+default-features = false
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[dependencies.frame-system]
+version = "2.0.0-rc1"
+default-features = false
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[dependencies.sp-std]
+version = "2.0.0-rc1"
+default-features = false
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[dependencies.sp-runtime]
+version = "2.0.0-rc1"
+default-features = false
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[dev-dependencies.sp-core]
+version = "2.0.0-rc1"
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[dev-dependencies.sp-io]
+version = "2.0.0-rc1"
+rev = "599ba75bc2b5acd238c21c5c7efe8e2ad8d401ee"
+git = "https://github.com/paritytech/substrate/"
+
+[features]
+default = ["std"]
+std = [
+	"serde",
+	"codec/std",
+	"sp-std/std",
+	"frame-support/std",
+	"frame-system/std",
+	"sp-runtime/std",
+	"sp-currency-exchange/std",
+]

bridges/modules/currency-exchange/src/lib.rs

@@ -0,0 +1,418 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Runtime module that allows tokens exchange between two bridged chains.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{decl_error, decl_module, decl_storage, ensure, Parameter};
+use sp_currency_exchange::{
+	CurrencyConverter, DepositInto, Error as ExchangeError, MaybeLockFundsTransaction, RecipientsMap,
+};
+use sp_runtime::DispatchResult;
+
+/// Called when transaction is submitted to the exchange module.
+pub trait OnTransactionSubmitted<AccountId> {
+	/// Called when valid transaction is submitted and accepted by the module.
+	fn on_valid_transaction_submitted(submitter: AccountId);
+}
+
+/// Peer blockhain interface.
+pub trait Blockchain {
+	/// Transaction type.
+	type Transaction: Parameter;
+	/// Transaction inclusion proof type.
+	type TransactionInclusionProof: Parameter;
+
+	/// Verify that transaction is a part of given block.
+	///
+	/// Returns Some(transaction) if proof is valid and None otherwise.
+	fn verify_transaction_inclusion_proof(proof: &Self::TransactionInclusionProof) -> Option<Self::Transaction>;
+}
+
+/// The module configuration trait
+pub trait Trait: frame_system::Trait {
+	/// Handler for transaction submission result.
+	type OnTransactionSubmitted: OnTransactionSubmitted<Self::AccountId>;
+	/// Peer blockchain type.
+	type PeerBlockchain: Blockchain;
+	/// Peer blockchain transaction parser.
+	type PeerMaybeLockFundsTransaction: MaybeLockFundsTransaction<
+		Transaction = <Self::PeerBlockchain as Blockchain>::Transaction,
+	>;
+	/// Map between blockchains recipients.
+	type RecipientsMap: RecipientsMap<
+		PeerRecipient = <Self::PeerMaybeLockFundsTransaction as MaybeLockFundsTransaction>::Recipient,
+		Recipient = Self::AccountId,
+	>;
+	/// This blockchain currency amount type.
+	type Amount;
+	/// Converter from peer blockchain currency type into current blockchain currency type.
+	type CurrencyConverter: CurrencyConverter<
+		SourceAmount = <Self::PeerMaybeLockFundsTransaction as MaybeLockFundsTransaction>::Amount,
+		TargetAmount = Self::Amount,
+	>;
+	/// Something that could grant money.
+	type DepositInto: DepositInto<Recipient = Self::AccountId, Amount = Self::Amount>;
+}
+
+decl_error! {
+	pub enum Error for Module<T: Trait> {
+		/// Invalid peer blockchain transaction provided.
+		InvalidTransaction,
+		/// Peer transaction has invalid amount.
+		InvalidAmount,
+		/// Peer transaction has invalid recipient.
+		InvalidRecipient,
+		/// Cannot map from peer recipient to this blockchain recipient.
+		FailedToMapRecipients,
+		/// Failed to convert from peer blockchain currency to this blockhain currency.
+		FailedToConvertCurrency,
+		/// Deposit has failed.
+		DepositFailed,
+		/// Transaction is not finalized.
+		UnfinalizedTransaction,
+		/// Transaction funds are already claimed.
+		AlreadyClaimed,
+	}
+}
+
+decl_module! {
+	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+		/// Imports lock fund transaction of the peer blockchain.
+		#[weight = 0] // TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+		pub fn import_peer_transaction(
+			origin,
+			proof: <<T as Trait>::PeerBlockchain as Blockchain>::TransactionInclusionProof,
+		) -> DispatchResult {
+			let submitter = frame_system::ensure_signed(origin)?;
+
+			// ensure that transaction is included in finalized block that we know of
+			let transaction = <T as Trait>::PeerBlockchain::verify_transaction_inclusion_proof(
+				&proof,
+			).ok_or_else(|| Error::<T>::UnfinalizedTransaction)?;
+
+			// parse transaction
+			let transaction = <T as Trait>::PeerMaybeLockFundsTransaction::parse(&transaction)
+				.map_err(Error::<T>::from)?;
+			let transfer_id = transaction.id;
+			ensure!(
+				!Transfers::<T>::contains_key(&transfer_id),
+				Error::<T>::AlreadyClaimed
+			);
+
+			// grant recipient
+			let recipient = T::RecipientsMap::map(transaction.recipient).map_err(Error::<T>::from)?;
+			let amount = T::CurrencyConverter::convert(transaction.amount).map_err(Error::<T>::from)?;
+
+			// make sure to update the mapping if we deposit successfully to avoid double spending,
+			// i.e. whenever `deposit_into` is successful we MUST update `Transfers`.
+			{
+				T::DepositInto::deposit_into(recipient, amount).map_err(Error::<T>::from)?;
+				Transfers::<T>::insert(transfer_id, ())
+			}
+
+			// reward submitter for providing valid message
+			T::OnTransactionSubmitted::on_valid_transaction_submitted(submitter);
+
+			Ok(())
+		}
+	}
+}
+
+decl_storage! {
+	trait Store for Module<T: Trait> as Bridge {
+		/// All transfers that have already been claimed.
+		Transfers: map hasher(blake2_128_concat) <T::PeerMaybeLockFundsTransaction as MaybeLockFundsTransaction>::Id => ();
+	}
+}
+
+impl<T: Trait> From<ExchangeError> for Error<T> {
+	fn from(error: ExchangeError) -> Self {
+		match error {
+			ExchangeError::InvalidTransaction => Error::InvalidTransaction,
+			ExchangeError::InvalidAmount => Error::InvalidAmount,
+			ExchangeError::InvalidRecipient => Error::InvalidRecipient,
+			ExchangeError::FailedToMapRecipients => Error::FailedToMapRecipients,
+			ExchangeError::FailedToConvertCurrency => Error::FailedToConvertCurrency,
+			ExchangeError::DepositFailed => Error::DepositFailed,
+		}
+	}
+}
+
+impl<AccountId> OnTransactionSubmitted<AccountId> for () {
+	fn on_valid_transaction_submitted(_: AccountId) {}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use frame_support::{assert_noop, assert_ok, impl_outer_origin, parameter_types, weights::Weight};
+	use sp_core::H256;
+	use sp_currency_exchange::LockFundsTransaction;
+	use sp_runtime::{
+		testing::Header,
+		traits::{BlakeTwo256, IdentityLookup},
+		Perbill,
+	};
+
+	type AccountId = u64;
+
+	const INVALID_TRANSACTION_ID: u64 = 100;
+	const ALREADY_CLAIMED_TRANSACTION_ID: u64 = 101;
+	const UNKNOWN_RECIPIENT_ID: u64 = 0;
+	const INVALID_AMOUNT: u64 = 0;
+	const MAX_DEPOSIT_AMOUNT: u64 = 1000;
+	const SUBMITTER: u64 = 2000;
+
+	type RawTransaction = LockFundsTransaction<u64, u64, u64>;
+
+	pub struct DummyTransactionSubmissionHandler;
+
+	impl OnTransactionSubmitted<AccountId> for DummyTransactionSubmissionHandler {
+		fn on_valid_transaction_submitted(submitter: AccountId) {
+			Transfers::<TestRuntime>::insert(submitter, ());
+		}
+	}
+
+	pub struct DummyBlockchain;
+
+	impl Blockchain for DummyBlockchain {
+		type Transaction = RawTransaction;
+		type TransactionInclusionProof = (bool, RawTransaction);
+
+		fn verify_transaction_inclusion_proof(proof: &Self::TransactionInclusionProof) -> Option<RawTransaction> {
+			if proof.0 {
+				Some(proof.1.clone())
+			} else {
+				None
+			}
+		}
+	}
+
+	pub struct DummyTransaction;
+
+	impl MaybeLockFundsTransaction for DummyTransaction {
+		type Transaction = RawTransaction;
+		type Id = u64;
+		type Recipient = AccountId;
+		type Amount = u64;
+
+		fn parse(tx: &Self::Transaction) -> sp_currency_exchange::Result<RawTransaction> {
+			match tx.id {
+				INVALID_TRANSACTION_ID => Err(sp_currency_exchange::Error::InvalidTransaction),
+				_ => Ok(tx.clone()),
+			}
+		}
+	}
+
+	pub struct DummyRecipientsMap;
+
+	impl RecipientsMap for DummyRecipientsMap {
+		type PeerRecipient = AccountId;
+		type Recipient = AccountId;
+
+		fn map(peer_recipient: Self::PeerRecipient) -> sp_currency_exchange::Result<Self::Recipient> {
+			match peer_recipient {
+				UNKNOWN_RECIPIENT_ID => Err(sp_currency_exchange::Error::FailedToMapRecipients),
+				_ => Ok(peer_recipient * 10),
+			}
+		}
+	}
+
+	pub struct DummyCurrencyConverter;
+
+	impl CurrencyConverter for DummyCurrencyConverter {
+		type SourceAmount = u64;
+		type TargetAmount = u64;
+
+		fn convert(amount: Self::SourceAmount) -> sp_currency_exchange::Result<Self::TargetAmount> {
+			match amount {
+				INVALID_AMOUNT => Err(sp_currency_exchange::Error::FailedToConvertCurrency),
+				_ => Ok(amount * 10),
+			}
+		}
+	}
+
+	pub struct DummyDepositInto;
+
+	impl DepositInto for DummyDepositInto {
+		type Recipient = AccountId;
+		type Amount = u64;
+
+		fn deposit_into(_recipient: Self::Recipient, amount: Self::Amount) -> sp_currency_exchange::Result<()> {
+			match amount > MAX_DEPOSIT_AMOUNT {
+				true => Err(sp_currency_exchange::Error::DepositFailed),
+				_ => Ok(()),
+			}
+		}
+	}
+
+	#[derive(Clone, Eq, PartialEq)]
+	pub struct TestRuntime;
+
+	impl_outer_origin! {
+		pub enum Origin for TestRuntime where system = frame_system {}
+	}
+
+	parameter_types! {
+		pub const BlockHashCount: u64 = 250;
+		pub const MaximumBlockWeight: Weight = 1024;
+		pub const MaximumBlockLength: u32 = 2 * 1024;
+		pub const AvailableBlockRatio: Perbill = Perbill::one();
+	}
+
+	impl frame_system::Trait for TestRuntime {
+		type Origin = Origin;
+		type Index = u64;
+		type Call = ();
+		type BlockNumber = u64;
+		type Hash = H256;
+		type Hashing = BlakeTwo256;
+		type AccountId = AccountId;
+		type Lookup = IdentityLookup<Self::AccountId>;
+		type Header = Header;
+		type Event = ();
+		type BlockHashCount = BlockHashCount;
+		type MaximumBlockWeight = MaximumBlockWeight;
+		type DbWeight = ();
+		type BlockExecutionWeight = ();
+		type ExtrinsicBaseWeight = ();
+		type MaximumExtrinsicWeight = ();
+		type AvailableBlockRatio = AvailableBlockRatio;
+		type MaximumBlockLength = MaximumBlockLength;
+		type Version = ();
+		type ModuleToIndex = ();
+		type AccountData = ();
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+	}
+
+	impl Trait for TestRuntime {
+		type OnTransactionSubmitted = DummyTransactionSubmissionHandler;
+		type PeerBlockchain = DummyBlockchain;
+		type PeerMaybeLockFundsTransaction = DummyTransaction;
+		type RecipientsMap = DummyRecipientsMap;
+		type Amount = u64;
+		type CurrencyConverter = DummyCurrencyConverter;
+		type DepositInto = DummyDepositInto;
+	}
+
+	type Exchange = Module<TestRuntime>;
+
+	fn new_test_ext() -> sp_io::TestExternalities {
+		let t = frame_system::GenesisConfig::default()
+			.build_storage::<TestRuntime>()
+			.unwrap();
+		sp_io::TestExternalities::new(t)
+	}
+
+	fn transaction(id: u64) -> RawTransaction {
+		RawTransaction {
+			id,
+			recipient: 1,
+			amount: 2,
+		}
+	}
+
+	#[test]
+	fn unfinalized_transaction_rejected() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(
+				Exchange::import_peer_transaction(Origin::signed(SUBMITTER), (false, transaction(0))),
+				Error::<TestRuntime>::UnfinalizedTransaction,
+			);
+		});
+	}
+
+	#[test]
+	fn invalid_transaction_rejected() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(
+				Exchange::import_peer_transaction(
+					Origin::signed(SUBMITTER),
+					(true, transaction(INVALID_TRANSACTION_ID)),
+				),
+				Error::<TestRuntime>::InvalidTransaction,
+			);
+		});
+	}
+
+	#[test]
+	fn claimed_transaction_rejected() {
+		new_test_ext().execute_with(|| {
+			<Exchange as crate::Store>::Transfers::insert(ALREADY_CLAIMED_TRANSACTION_ID, ());
+			assert_noop!(
+				Exchange::import_peer_transaction(
+					Origin::signed(SUBMITTER),
+					(true, transaction(ALREADY_CLAIMED_TRANSACTION_ID)),
+				),
+				Error::<TestRuntime>::AlreadyClaimed,
+			);
+		});
+	}
+
+	#[test]
+	fn transaction_with_unknown_recipient_rejected() {
+		new_test_ext().execute_with(|| {
+			let mut transaction = transaction(0);
+			transaction.recipient = UNKNOWN_RECIPIENT_ID;
+			assert_noop!(
+				Exchange::import_peer_transaction(Origin::signed(SUBMITTER), (true, transaction)),
+				Error::<TestRuntime>::FailedToMapRecipients,
+			);
+		});
+	}
+
+	#[test]
+	fn transaction_with_invalid_amount_rejected() {
+		new_test_ext().execute_with(|| {
+			let mut transaction = transaction(0);
+			transaction.amount = INVALID_AMOUNT;
+			assert_noop!(
+				Exchange::import_peer_transaction(Origin::signed(SUBMITTER), (true, transaction)),
+				Error::<TestRuntime>::FailedToConvertCurrency,
+			);
+		});
+	}
+
+	#[test]
+	fn transaction_with_invalid_deposit_rejected() {
+		new_test_ext().execute_with(|| {
+			let mut transaction = transaction(0);
+			transaction.amount = MAX_DEPOSIT_AMOUNT;
+			assert_noop!(
+				Exchange::import_peer_transaction(Origin::signed(SUBMITTER), (true, transaction)),
+				Error::<TestRuntime>::DepositFailed,
+			);
+		});
+	}
+
+	#[test]
+	fn valid_transaction_accepted() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Exchange::import_peer_transaction(
+				Origin::signed(SUBMITTER),
+				(true, transaction(0)),
+			),);
+
+			// ensure that the transfer has been marked as completed
+			assert!(<Exchange as crate::Store>::Transfers::contains_key(0u64));
+			// ensure that submitter has been rewarded
+			assert!(<Exchange as crate::Store>::Transfers::contains_key(SUBMITTER));
+		});
+	}
+}

bridges/modules/ethereum/src/finality.rs

@@ -103,7 +103,7 @@ fn prepare_votes<S: Storage>(
 	// we only take ancestors that are not yet pruned and those signed by
 	// the same set of validators
 	let mut parent_empty_step_signers = empty_steps_signers(header);
-	let ancestry = ancestry(storage, header)
+	let ancestry = ancestry(storage, header.parent_hash)
 		.map(|(hash, header, submitter)| {
 			let mut signers = BTreeSet::new();
 			sp_std::mem::swap(&mut signers, &mut parent_empty_step_signers);
@@ -196,9 +196,8 @@ fn empty_step_signer(empty_step: &SealedEmptyStep, parent_hash: &H256) -> Option
 /// Return iterator of given header ancestors.
 pub(crate) fn ancestry<'a, S: Storage>(
 	storage: &'a S,
-	header: &Header,
+	mut parent_hash: H256,
 ) -> impl Iterator<Item = (H256, Header, Option<S::Submitter>)> + 'a {
-	let mut parent_hash = header.parent_hash.clone();
 	from_fn(move || {
 		let (header, submitter) = storage.header(&parent_hash)?;
 		if header.number == 0 {

bridges/modules/ethereum/src/lib.rs

@@ -18,7 +18,7 @@
 
 use codec::{Decode, Encode};
 use frame_support::{decl_module, decl_storage, traits::Get};
-use primitives::{Address, Header, Receipt, H256, U256};
+use primitives::{Address, Header, RawTransaction, Receipt, H256, U256};
 use sp_runtime::{
 	transaction_validity::{
 		InvalidTransaction, TransactionLongevity, TransactionPriority, TransactionSource, TransactionValidity,
@@ -456,6 +456,11 @@ impl<T: Trait> Module<T> {
 	pub fn is_known_block(hash: H256) -> bool {
 		BridgeStorage::<T>::new().header(&hash).is_some()
 	}
+
+	/// Verify that transaction is included into given finalized block.
+	pub fn verify_transaction_finalized(block: H256, tx_index: u64, proof: &Vec<RawTransaction>) -> bool {
+		crate::verify_transaction_finalized(&BridgeStorage::<T>::new(), block, tx_index, proof)
+	}
 }
 
 impl<T: Trait> frame_support::unsigned::ValidateUnsigned for Module<T> {
@@ -672,6 +677,13 @@ impl<T: Trait> Storage for BridgeStorage<T> {
 			}
 		};
 
+		frame_support::debug::trace!(
+			target: "runtime",
+			"Inserting PoA header: ({}, {})",
+			header.header.number,
+			header.hash,
+		);
+
 		let last_signal_block = header.context.last_signal_block().cloned();
 		HeadersByNumber::append(header.header.number, header.hash);
 		Headers::<T>::insert(
@@ -693,6 +705,13 @@ impl<T: Trait> Storage for BridgeStorage<T> {
 			.map(|f| f.0)
 			.unwrap_or_else(|| FinalizedBlock::get().0);
 		if let Some(finalized) = finalized {
+			frame_support::debug::trace!(
+				target: "runtime",
+				"Finalizing PoA header: ({}, {})",
+				finalized.0,
+				finalized.1,
+			);
+
 			FinalizedBlock::put(finalized);
 		}
 
@@ -701,6 +720,44 @@ impl<T: Trait> Storage for BridgeStorage<T> {
 	}
 }
 
+/// Verify that transaction is included into given finalized block.
+pub fn verify_transaction_finalized<S: Storage>(
+	storage: &S,
+	block: H256,
+	tx_index: u64,
+	proof: &Vec<RawTransaction>,
+) -> bool {
+	if tx_index >= proof.len() as _ {
+		return false;
+	}
+
+	let header = match storage.header(&block) {
+		Some((header, _)) => header,
+		None => return false,
+	};
+	let (finalized_number, finalized_hash) = storage.finalized_block();
+
+	// if header is not yet finalized => return
+	if header.number > finalized_number {
+		return false;
+	}
+
+	// check if header is actually finalized
+	let is_finalized = match header.number < finalized_number {
+		true => finality::ancestry(storage, finalized_hash)
+			.skip_while(|(_, ancestor, _)| ancestor.number > header.number)
+			.filter(|&(ancestor_hash, _, _)| ancestor_hash == block)
+			.next()
+			.is_some(),
+		false => block == finalized_hash,
+	};
+	if !is_finalized {
+		return false;
+	}
+
+	header.verify_transactions_root(proof)
+}
+
 /// Transaction pool configuration.
 fn pool_configuration() -> PoolConfiguration {
 	PoolConfiguration {
@@ -709,9 +766,12 @@ fn pool_configuration() -> PoolConfiguration {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
 	use super::*;
-	use crate::mock::{custom_block_i, custom_test_ext, genesis, validators, validators_addresses, TestRuntime};
+	use crate::mock::{
+		custom_block_i, custom_test_ext, genesis, insert_header, validators, validators_addresses, TestRuntime,
+	};
+	use primitives::compute_merkle_root;
 
 	fn with_headers_to_prune<T>(f: impl Fn(BridgeStorage<TestRuntime>) -> T) -> T {
 		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
@@ -874,4 +934,133 @@ mod tests {
 			);
 		});
 	}
+
+	fn example_tx() -> Vec<u8> {
+		vec![42]
+	}
+
+	fn example_header() -> Header {
+		let mut header = Header::default();
+		header.number = 2;
+		header.transactions_root = compute_merkle_root(vec![example_tx()].into_iter());
+		header.parent_hash = example_header_parent().hash();
+		header
+	}
+
+	fn example_header_parent() -> Header {
+		let mut header = Header::default();
+		header.number = 1;
+		header.transactions_root = compute_merkle_root(vec![example_tx()].into_iter());
+		header.parent_hash = genesis().hash();
+		header
+	}
+
+	#[test]
+	fn verify_transaction_finalized_works_for_best_finalized_header() {
+		custom_test_ext(example_header(), validators_addresses(3)).execute_with(|| {
+			let storage = BridgeStorage::<TestRuntime>::new();
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header().hash(), 0, &vec![example_tx()],),
+				true,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_works_for_best_finalized_header_ancestor() {
+		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
+			let mut storage = BridgeStorage::<TestRuntime>::new();
+			insert_header(&mut storage, example_header_parent());
+			insert_header(&mut storage, example_header());
+			storage.finalize_headers(Some((example_header().number, example_header().hash())), None);
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header_parent().hash(), 0, &vec![example_tx()],),
+				true,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_proof_with_missing_tx() {
+		custom_test_ext(example_header(), validators_addresses(3)).execute_with(|| {
+			let storage = BridgeStorage::<TestRuntime>::new();
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header().hash(), 1, &vec![],),
+				false,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_unknown_header() {
+		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
+			let storage = BridgeStorage::<TestRuntime>::new();
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header().hash(), 1, &vec![],),
+				false,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_unfinalized_header() {
+		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
+			let mut storage = BridgeStorage::<TestRuntime>::new();
+			insert_header(&mut storage, example_header_parent());
+			insert_header(&mut storage, example_header());
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header().hash(), 0, &vec![example_tx()],),
+				false,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_finalized_header_sibling() {
+		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
+			let mut finalized_header_sibling = example_header();
+			finalized_header_sibling.timestamp = 1;
+			let finalized_header_sibling_hash = finalized_header_sibling.hash();
+
+			let mut storage = BridgeStorage::<TestRuntime>::new();
+			insert_header(&mut storage, example_header_parent());
+			insert_header(&mut storage, example_header());
+			insert_header(&mut storage, finalized_header_sibling);
+			storage.finalize_headers(Some((example_header().number, example_header().hash())), None);
+			assert_eq!(
+				verify_transaction_finalized(&storage, finalized_header_sibling_hash, 0, &vec![example_tx()],),
+				false,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_finalized_header_uncle() {
+		custom_test_ext(genesis(), validators_addresses(3)).execute_with(|| {
+			let mut finalized_header_uncle = example_header_parent();
+			finalized_header_uncle.timestamp = 1;
+			let finalized_header_uncle_hash = finalized_header_uncle.hash();
+
+			let mut storage = BridgeStorage::<TestRuntime>::new();
+			insert_header(&mut storage, example_header_parent());
+			insert_header(&mut storage, finalized_header_uncle);
+			insert_header(&mut storage, example_header());
+			storage.finalize_headers(Some((example_header().number, example_header().hash())), None);
+			assert_eq!(
+				verify_transaction_finalized(&storage, finalized_header_uncle_hash, 0, &vec![example_tx()],),
+				false,
+			);
+		});
+	}
+
+	#[test]
+	fn verify_transaction_finalized_rejects_invalid_proof() {
+		custom_test_ext(example_header(), validators_addresses(3)).execute_with(|| {
+			let storage = BridgeStorage::<TestRuntime>::new();
+			assert_eq!(
+				verify_transaction_finalized(&storage, example_header().hash(), 0, &vec![example_tx(), example_tx(),],),
+				false,
+			);
+		});
+	}
 }

bridges/modules/ethereum/src/validators.rs

@@ -129,7 +129,7 @@ impl<'a> Validators<'a> {
 		}
 
 		let receipts = receipts.ok_or(Error::MissingTransactionsReceipts)?;
-		if !header.check_transactions_receipts(&receipts) {
+		if !header.verify_receipts_root(&receipts) {
 			return Err(Error::TransactionsReceiptsMismatch);
 		}
 

bridges/modules/ethereum/src/verification.rs

@@ -134,7 +134,7 @@ pub fn accept_aura_header_into_pool<S: Storage>(
 
 	// the heaviest, but rare operation - we do not want invalid receipts in the pool
 	if let Some(receipts) = receipts {
-		if !header.check_transactions_receipts(receipts) {
+		if !header.verify_receipts_root(receipts) {
 			return Err(Error::TransactionsReceiptsMismatch);
 		}
 	}