feat: verify transaction metadata (#4078)(PRO-819)

engine/src/eth/retry_rpc.rs

@@ -102,6 +102,8 @@ pub trait EthersRetryRpcApi: Clone {
 		newest_block: BlockNumber,
 		reward_percentiles: Vec<f64>,
 	) -> FeeHistory;
+
+	async fn get_transaction(&self, tx_hash: H256) -> Transaction;
 }
 
 #[async_trait::async_trait]
@@ -262,6 +264,18 @@ impl EthersRetryRpcApi for EthersRetryRpcClient {
 			)
 			.await
 	}
+
+	async fn get_transaction(&self, tx_hash: H256) -> Transaction {
+		self.rpc_retry_client
+			.request(
+				Box::pin(move |client| {
+					#[allow(clippy::redundant_async_block)]
+					Box::pin(async move { client.get_transaction(tx_hash).await })
+				}),
+				RequestLog::new("get_transaction".to_string(), Some(format!("{tx_hash:?}"))),
+			)
+			.await
+	}
 }
 
 #[async_trait::async_trait]
@@ -360,6 +374,8 @@ pub mod mocks {
 				newest_block: BlockNumber,
 				reward_percentiles: Vec<f64>,
 			) -> FeeHistory;
+
+			async fn get_transaction(&self, tx_hash: H256) -> Transaction;
 		}
 	}
 }

engine/src/eth/rpc.rs

@@ -125,6 +125,8 @@ pub trait EthRpcApi: Send {
 		newest_block: BlockNumber,
 		reward_percentiles: &[f64],
 	) -> Result<FeeHistory>;
+
+	async fn get_transaction(&self, tx_hash: H256) -> Result<Transaction>;
 }
 
 #[async_trait::async_trait]
@@ -186,6 +188,13 @@ impl EthRpcApi for EthRpcClient {
 	) -> Result<FeeHistory> {
 		Ok(self.signer.fee_history(block_count, last_block, reward_percentiles).await?)
 	}
+
+	async fn get_transaction(&self, tx_hash: H256) -> Result<Transaction> {
+		self.signer
+			.get_transaction(tx_hash)
+			.await?
+			.ok_or_else(|| anyhow!("Getting ETH transaction for tx hash {} returned None", tx_hash))
+	}
 }
 
 /// On each subscription this will create a new WS connection.

engine/src/witness/btc.rs

@@ -55,6 +55,7 @@ pub async fn process_egress<ProcessCall, ProcessingFut, ExtraInfo, ExtraHistoric
 					)
 					.script_pubkey(),
 					tx_fee: Default::default(),
+					tx_metadata: Default::default(),
 				},
 			),
 			epoch.index,

engine/src/witness/dot.rs

@@ -160,6 +160,7 @@ pub async fn process_egress<ProcessCall, ProcessingFut>(
 							tx_out_id: signature,
 							signer_id: epoch.info.1,
 							tx_fee,
+							tx_metadata: Default::default(),
 						}
 						.into(),
 						epoch.index,

engine/src/witness/eth/key_manager.rs

@@ -1,4 +1,6 @@
-use cf_chains::evm::{EvmCrypto, SchnorrVerificationComponents, TransactionFee};
+use cf_chains::evm::{
+	EvmCrypto, SchnorrVerificationComponents, TransactionFee, TransactionMetadata,
+};
 use cf_primitives::EpochIndex;
 use ethers::{
 	prelude::abigen,
@@ -60,6 +62,7 @@ impl<Inner: ChunkedByVault> ChunkedByVaultBuilder<Inner> {
 			ChainCrypto = EvmCrypto,
 			ChainAccount = H160,
 			TransactionFee = TransactionFee,
+			TransactionMetaData = TransactionMetadata,
 		>,
 		ProcessCall: Fn(state_chain_runtime::RuntimeCall, EpochIndex) -> ProcessingFut
 			+ Send
@@ -107,8 +110,9 @@ impl<Inner: ChunkedByVault> ChunkedByVaultBuilder<Inner> {
 							sig_data,
 							..
 						}) => {
-							let TransactionReceipt { gas_used, effective_gas_price, from, .. } =
-								eth_rpc.transaction_receipt(event.tx_hash).await;
+							let TransactionReceipt {
+								gas_used, effective_gas_price, from, to, ..
+							} = eth_rpc.transaction_receipt(event.tx_hash).await;
 
 							let gas_used = gas_used
 								.ok_or_else(|| {
@@ -127,6 +131,14 @@ impl<Inner: ChunkedByVault> ChunkedByVaultBuilder<Inner> {
 								})?
 								.try_into()
 								.map_err(anyhow::Error::msg)?;
+
+							let transaction = eth_rpc.get_transaction(event.tx_hash).await;
+							let tx_metadata = TransactionMetadata {
+								contract: to.expect("To have a contract"),
+								max_fee_per_gas: transaction.max_fee_per_gas,
+								max_priority_fee_per_gas: transaction.max_priority_fee_per_gas,
+								gas_limit: Some(transaction.gas),
+							};
 							pallet_cf_broadcast::Call::<
 								_,
 								<Inner::Chain as PalletInstanceAlias>::Instance,
@@ -137,6 +149,7 @@ impl<Inner: ChunkedByVault> ChunkedByVaultBuilder<Inner> {
 								},
 								signer_id: from,
 								tx_fee: TransactionFee { effective_gas_price, gas_used },
+								tx_metadata,
 							}
 							.into()
 						},

state-chain/chains/src/any.rs

@@ -1,4 +1,7 @@
-use crate::{address::ForeignChainAddress, none::NoneChainCrypto, Chain, FeeRefundCalculator};
+use crate::{
+	address::ForeignChainAddress, none::NoneChainCrypto, Chain, FeeRefundCalculator,
+	TransactionMetaDataHandler,
+};
 
 use cf_primitives::{
 	chains::{assets, AnyChain},
@@ -19,6 +22,7 @@ impl Chain for AnyChain {
 	type DepositChannelState = ();
 	type DepositDetails = ();
 	type Transaction = ();
+	type TransactionMetaData = ();
 	type ReplayProtectionParams = ();
 	type ReplayProtection = ();
 }
@@ -31,3 +35,18 @@ impl FeeRefundCalculator<AnyChain> for () {
 		unimplemented!()
 	}
 }
+
+impl TransactionMetaDataHandler<AnyChain> for () {
+	fn extract_metadata(
+		_transaction: &<AnyChain as Chain>::Transaction,
+	) -> <AnyChain as Chain>::TransactionMetaData {
+		unimplemented!()
+	}
+
+	fn verify_metadata(
+		_metadata: &<AnyChain as Chain>::TransactionMetaData,
+		_expected_metadata: &<AnyChain as Chain>::TransactionMetaData,
+	) -> bool {
+		unimplemented!()
+	}
+}

state-chain/chains/src/benchmarking_value.rs

@@ -3,13 +3,15 @@ use cf_primitives::{
 	chains::assets::{btc, dot, eth},
 	Asset,
 };
+use ethereum_types::{H160, U256};
 
 #[cfg(feature = "runtime-benchmarks")]
 use crate::address::EncodedAddress;
 #[cfg(feature = "runtime-benchmarks")]
 use crate::address::ForeignChainAddress;
 #[cfg(feature = "runtime-benchmarks")]
 use crate::evm::EvmFetchId;
+use crate::evm::TransactionMetadata;
 
 /// Ensure type specifies a value to be used for benchmarking purposes.
 pub trait BenchmarkValue {
@@ -120,6 +122,19 @@ impl BenchmarkValueExtended for () {
 		Default::default()
 	}
 }
+
+#[cfg(feature = "runtime-benchmarks")]
+impl BenchmarkValue for TransactionMetadata {
+	fn benchmark_value() -> Self {
+		TransactionMetadata {
+			contract: H160::zero(),
+			max_fee_per_gas: Some(U256::zero()),
+			max_priority_fee_per_gas: Some(U256::zero()),
+			gas_limit: None,
+		}
+	}
+}
+
 impl_default_benchmark_value!(());
 impl_default_benchmark_value!(u32);
 impl_default_benchmark_value!(u64);

state-chain/chains/src/btc.rs

@@ -7,7 +7,7 @@ extern crate alloc;
 use core::{cmp::max, mem::size_of};
 
 use self::deposit_address::DepositAddress;
-use crate::{Chain, ChainCrypto, DepositChannel, FeeRefundCalculator};
+use crate::{Chain, ChainCrypto, DepositChannel, FeeRefundCalculator, TransactionMetaDataHandler};
 use alloc::{collections::VecDeque, string::String};
 use arrayref::array_ref;
 use base58::{FromBase58, ToBase58};
@@ -187,11 +187,27 @@ impl Chain for Bitcoin {
 	type DepositChannelState = DepositAddress;
 	type DepositDetails = UtxoId;
 	type Transaction = BitcoinTransactionData;
+	type TransactionMetaData = ();
 	// There is no need for replay protection on Bitcoin since it is a UTXO chain.
 	type ReplayProtectionParams = ();
 	type ReplayProtection = ();
 }
 
+impl TransactionMetaDataHandler<Bitcoin> for () {
+	fn extract_metadata(
+		_transaction: &<Bitcoin as Chain>::Transaction,
+	) -> <Bitcoin as Chain>::TransactionMetaData {
+		Default::default()
+	}
+
+	fn verify_metadata(
+		_metadata: &<Bitcoin as Chain>::TransactionMetaData,
+		_expected_metadata: &<Bitcoin as Chain>::TransactionMetaData,
+	) -> bool {
+		true
+	}
+}
+
 #[derive(Clone, Copy, Encode, Decode, MaxEncodedLen, TypeInfo, Debug, PartialEq, Eq)]
 pub enum PreviousOrCurrent {
 	Previous,

state-chain/chains/src/dot.rs

@@ -194,6 +194,23 @@ impl PolkadotUncheckedExtrinsic {
 	}
 }
 
+pub struct PolkadotTransactionMetaDataHandler;
+
+impl TransactionMetaDataHandler<Polkadot> for PolkadotTransactionMetaDataHandler {
+	fn extract_metadata(
+		_transaction: &<Polkadot as Chain>::Transaction,
+	) -> <Polkadot as Chain>::TransactionMetaData {
+		Default::default()
+	}
+
+	fn verify_metadata(
+		_metadata: &<Polkadot as Chain>::TransactionMetaData,
+		_expected_metadata: &<Polkadot as Chain>::TransactionMetaData,
+	) -> bool {
+		true
+	}
+}
+
 /// The payload being signed in transactions.
 pub type PolkadotPayload = SignedPayload<PolkadotRuntimeCall, PolkadotSignedExtra>;
 
@@ -267,10 +284,26 @@ impl Chain for Polkadot {
 	type DepositChannelState = PolkadotChannelState;
 	type DepositDetails = ();
 	type Transaction = PolkadotTransactionData;
+	type TransactionMetaData = ();
 	type ReplayProtectionParams = ResetProxyAccountNonce;
 	type ReplayProtection = PolkadotReplayProtection;
 }
 
+impl TransactionMetaDataHandler<Polkadot> for () {
+	fn extract_metadata(
+		_transaction: &<Polkadot as Chain>::Transaction,
+	) -> <Polkadot as Chain>::TransactionMetaData {
+		Default::default()
+	}
+
+	fn verify_metadata(
+		_metadata: &<Polkadot as Chain>::TransactionMetaData,
+		_expected_metadata: &<Polkadot as Chain>::TransactionMetaData,
+	) -> bool {
+		true
+	}
+}
+
 pub type ResetProxyAccountNonce = bool;
 
 #[derive(Clone, Encode, Decode, MaxEncodedLen, TypeInfo, Debug, PartialEq, Eq, Default)]

state-chain/chains/src/eth.rs

@@ -6,7 +6,7 @@ pub mod benchmarking;
 pub mod deposit_address;
 
 use crate::{
-	evm::{DeploymentStatus, EvmFetchId, Transaction},
+	evm::{DeploymentStatus, EvmFetchId, Transaction, TransactionMetadata},
 	*,
 };
 use cf_primitives::chains::assets;
@@ -43,6 +43,7 @@ impl Chain for Ethereum {
 	type DepositChannelState = DeploymentStatus;
 	type DepositDetails = ();
 	type Transaction = Transaction;
+	type TransactionMetaData = TransactionMetadata;
 	type ReplayProtectionParams = Self::ChainAccount;
 	type ReplayProtection = EvmReplayProtection;
 }
@@ -113,6 +114,35 @@ impl From<&DepositChannel<Ethereum>> for EvmFetchId {
 	}
 }
 
+pub struct EthTransactionMetaDataHandler;
+
+impl TransactionMetaDataHandler<Ethereum> for EthTransactionMetaDataHandler {
+	fn extract_metadata(
+		transaction: &<Ethereum as Chain>::Transaction,
+	) -> <Ethereum as Chain>::TransactionMetaData {
+		TransactionMetadata {
+			contract: transaction.contract,
+			max_fee_per_gas: transaction.max_fee_per_gas,
+			max_priority_fee_per_gas: transaction.max_priority_fee_per_gas,
+			gas_limit: transaction.gas_limit,
+		}
+	}
+
+	fn verify_metadata(
+		metadata: &<Ethereum as Chain>::TransactionMetaData,
+		expected_metadata: &<Ethereum as Chain>::TransactionMetaData,
+	) -> bool {
+		metadata.contract == expected_metadata.contract &&
+			(expected_metadata.max_fee_per_gas.is_none() ||
+				expected_metadata.max_fee_per_gas == metadata.max_fee_per_gas) &&
+			(expected_metadata.max_priority_fee_per_gas.is_none() ||
+				expected_metadata.max_priority_fee_per_gas ==
+					metadata.max_priority_fee_per_gas) &&
+			(expected_metadata.gas_limit.is_none() ||
+				expected_metadata.gas_limit == metadata.gas_limit)
+	}
+}
+
 #[cfg(any(test, feature = "runtime-benchmarks"))]
 pub mod sig_constants {
 	/*

state-chain/chains/src/evm.rs

@@ -351,6 +351,43 @@ pub struct Transaction {
 	pub data: Vec<u8>,
 }
 
+#[derive(
+	Encode, Decode, TypeInfo, Clone, RuntimeDebug, Default, PartialEq, Eq, Serialize, Deserialize,
+)]
+pub struct TransactionMetadata {
+	pub max_fee_per_gas: Option<Uint>,
+	pub max_priority_fee_per_gas: Option<Uint>,
+	pub contract: Address,
+	pub gas_limit: Option<Uint>,
+}
+
+impl TransactionMetaDataHandler<Ethereum> for TransactionMetadata {
+	fn extract_metadata(
+		transaction: &<Ethereum as Chain>::Transaction,
+	) -> <Ethereum as Chain>::TransactionMetaData {
+		TransactionMetadata {
+			contract: transaction.contract,
+			max_fee_per_gas: transaction.max_fee_per_gas,
+			max_priority_fee_per_gas: transaction.max_priority_fee_per_gas,
+			gas_limit: transaction.gas_limit,
+		}
+	}
+
+	fn verify_metadata(
+		metadata: &<Ethereum as Chain>::TransactionMetaData,
+		expected_metadata: &<Ethereum as Chain>::TransactionMetaData,
+	) -> bool {
+		metadata.contract == expected_metadata.contract &&
+			(expected_metadata.max_fee_per_gas.is_none() ||
+				expected_metadata.max_fee_per_gas == metadata.max_fee_per_gas) &&
+			(expected_metadata.max_priority_fee_per_gas.is_none() ||
+				expected_metadata.max_priority_fee_per_gas ==
+					metadata.max_priority_fee_per_gas) &&
+			(expected_metadata.gas_limit.is_none() ||
+				expected_metadata.gas_limit == metadata.gas_limit)
+	}
+}
+
 impl Transaction {
 	fn check_contract(
 		&self,