Test MessageRelayer

Cargo.toml

@@ -1,17 +1,16 @@
 [package]
-
 name = "minimal-rollup"
 version = "0.1.0"
 edition = "2021"
 
+[lib]
+name = "minimal_rollup"
+path = "offchain/lib.rs"
+
 [[bin]]
 name = "signal_slot"
 path = "offchain/signal_slot.rs"
 
-[[bin]]
-name = "utils"
-path = "offchain/utils.rs"
-
 [[bin]]
 name = "sample_signal_proof"
 path = "offchain/sample_signal_proof.rs"

offchain/sample_deposit_proof.rs

@@ -1,15 +1,25 @@
+use alloy::primitives::utils::parse_units;
+use alloy::sol_types::SolCall;
 use eyre::Result;
 
 mod signal_slot;
 use signal_slot::get_signal_slot;
 
-mod utils;
-use utils::{deploy_eth_bridge, deploy_signal_service, get_proofs, get_provider, SignalProof};
+use minimal_rollup::{
+    deploy_eth_bridge, deploy_signal_service, get_proofs, get_provider, SignalProof,
+};
 
-use alloy::hex::decode;
+use alloy::hex::{self, decode};
 use alloy::primitives::{Address, Bytes, FixedBytes, U256};
 use std::fs;
 
+use alloy::sol;
+
+sol! {
+    function somePayableFunction(uint256 someArg) external payable returns (uint256);
+    function someNonpayableFunction(uint256 someArg) external returns (uint256);
+}
+
 fn expand_vector(vec: Vec<Bytes>, name: &str) -> String {
     let mut expanded = String::new();
     for (i, item) in vec.iter().enumerate() {
@@ -20,7 +30,7 @@ fn expand_vector(vec: Vec<Bytes>, name: &str) -> String {
     return expanded;
 }
 
-fn create_deposit_call(
+pub fn create_deposit_call(
     proof: SignalProof,
     nonce: usize,
     signer: Address,
@@ -66,14 +76,33 @@ fn deposit_specification() -> Vec<DepositSpecification> {
     // This is an address on the destination chain, so it seems natural to use one generated there
     // In this case, the CrossChainDepositExists.sol test case defines _randomAddress("recipient");
     let recipient = "0x99A270Be1AA5E97633177041859aEEB9a0670fAa";
+
     // Use both zero and non-zero amounts (in this case 4 ether)
-    let amounts = vec![0_u128, 4000000000000000000_u128];
+    let amounts: Vec<U256> = vec![U256::ZERO, parse_units("4", "ether").unwrap().into()];
+
     // Use different calldata to try different functions and inputs
+    let valid_payable_function_call = somePayableFunctionCall {
+        someArg: U256::from(1234),
+    }
+    .abi_encode();
+    let invalid_payable_function_call = somePayableFunctionCall {
+        someArg: U256::from(1235),
+    }
+    .abi_encode();
+    let valid_nonpayable_function_call = someNonpayableFunctionCall {
+        someArg: U256::from(1234),
+    }
+    .abi_encode();
+
+    let valid_payable_encoded = hex::encode(valid_payable_function_call);
+    let invalid_payable_encoded = hex::encode(invalid_payable_function_call);
+    let valid_nonpayable_encoded = hex::encode(valid_nonpayable_function_call);
+
     let calldata = vec![
-        "",                                                                         // empty
-        "9b28f6fb00000000000000000000000000000000000000000000000000000000000004d2", // (valid) call to somePayableFunction(1234)
-        "9b28f6fb00000000000000000000000000000000000000000000000000000000000004d3", // (invalid) call to somePayableFunction(1235)
-        "5932a71200000000000000000000000000000000000000000000000000000000000004d2", // (valid) call to `someNonPayableFunction(1234)`
+        "",
+        &valid_payable_encoded,
+        &invalid_payable_encoded,
+        &valid_nonpayable_encoded,
     ];
 
     let zero_canceler = Address::ZERO;
@@ -102,6 +131,7 @@ async fn main() -> Result<()> {
     let deposits = deposit_specification();
     assert!(deposits.len() > 0, "No deposits to prove");
     let mut ids: Vec<FixedBytes<32>> = vec![];
+
     // Perform all deposits
     for (_i, spec) in deposits.iter().enumerate() {
         let tx = eth_bridge
@@ -150,7 +180,7 @@ async fn main() -> Result<()> {
         .as_str();
     }
 
-    let template = fs::read_to_string("offchain/sample_deposit_proof.tmpl")?;
+    let template = fs::read_to_string("offchain/tmpl/sample_deposit_proof.tmpl")?;
     let formatted = template
         .replace(
             "{signal_service_address}",

offchain/sample_signal_proof.rs

@@ -3,8 +3,7 @@ use eyre::Result;
 mod signal_slot;
 use signal_slot::get_signal_slot;
 
-mod utils;
-use utils::{deploy_signal_service, get_proofs, get_provider};
+use minimal_rollup::{deploy_signal_service, get_proofs, get_provider};
 
 use alloy::primitives::Bytes;
 use std::fs;
@@ -32,7 +31,7 @@ async fn main() -> Result<()> {
     let proof   = get_proofs(&provider, slot, &signal_service).await?;
 
 
-    let template = fs::read_to_string("offchain/sample_proof.tmpl")?;
+    let template = fs::read_to_string("offchain/tmpl/sample_proof.tmpl")?;
     let formatted = template
         .replace("{signal_service_address}", signal_service.address().to_string().as_str())
         .replace("{block_hash}", proof.block_hash.to_string().as_str())
@@ -47,4 +46,3 @@ async fn main() -> Result<()> {
     println!("{}", formatted);
     Ok(())
 }
-

src/protocol/IMessageRelayer.sol

@@ -19,6 +19,9 @@ interface IMessageRelayer {
     /// @dev Message forwarding failed
     error MessageForwardingFailed();
 
+    /// @dev Value sent is higher than tip amount
+    error InsufficientValue();
+
     /// @dev Tip transfer failed
     error TipTransferFailed();
 

src/protocol/taiko_alethia/MessageRelayer.sol

@@ -90,6 +90,7 @@ contract MessageRelayer is ReentrancyGuardTransient, IMessageRelayer {
             tipRecipient = TIP_RECIPIENT_SLOT.asAddress().tload();
         }
 
+        require(msg.value >= tip, InsufficientValue());
         uint256 valueToSend = msg.value - tip;
         bool forwardMessageSuccess;