apollo_integration_tests: add mocked starknet contract (#8459) (#9724)

* apollo_integration_tests: ban `anvil` in unit tests

* l1: add mocked starknet contract

Mocked contract has mocked initialize and update state functions, but is
otherwise identical, is intended for use in anvil-based integraiton
tests.

Scraper test needed a fix, it wasn't passing fee, and not that the
contract is initialized it checks this. Also the cancellation request
wasn't sent from the correct sender, which was also not previously
checked.

---------

Co-authored-by: giladchase <[email protected]>
Co-authored-by: Gilad Chase <[email protected]>

Author: 3 people

crates/apollo_integration_tests/src/anvil_base_layer.rs

@@ -1,9 +1,11 @@
 use std::ops::RangeInclusive;
 
 use alloy::node_bindings::NodeError as AnvilError;
-use alloy::primitives::U256;
+use alloy::primitives::{I256, U256};
 use alloy::providers::{DynProvider, Provider, ProviderBuilder};
 use alloy::rpc::types::TransactionReceipt;
+use alloy::sol;
+use alloy::sol_types::SolValue;
 use async_trait::async_trait;
 use colored::*;
 use papyrus_base_layer::ethereum_base_layer_contract::{
@@ -84,10 +86,13 @@ impl AnvilBaseLayer {
         let root_client = anvil_client.root().clone();
         let contract = Starknet::new(config.starknet_contract_address, root_client);
 
-        Self {
+        let anvil_base_layer = Self {
             anvil_provider: anvil_client.erased(),
             ethereum_base_layer: EthereumBaseLayerContract { config, contract, url },
-        }
+        };
+        anvil_base_layer.initialize_mocked_starknet_contract().await;
+
+        anvil_base_layer
     }
 
     pub async fn send_message_to_l2(
@@ -107,6 +112,66 @@ impl AnvilBaseLayer {
             ..Default::default()
         }
     }
+
+    pub async fn update_mocked_starknet_contract_state(
+        &self,
+        update: MockedStateUpdate,
+    ) -> Result<(), EthereumBaseLayerError> {
+        // Size out output in the starknet contract, most of these aren't checked in the mock.
+        let mut output = vec![U256::from(0); starknet_output::HEADER_SIZE + 2];
+
+        output[starknet_output::PREV_BLOCK_NUMBER_OFFSET] = U256::from(update.new_block_number - 1);
+        output[starknet_output::NEW_BLOCK_NUMBER_OFFSET] = U256::from(update.new_block_number);
+        output[starknet_output::PREV_BLOCK_HASH_OFFSET] = U256::from(update.prev_block_hash);
+        output[starknet_output::NEW_BLOCK_HASH_OFFSET] = U256::from(update.new_block_hash);
+
+        // Run eth_call first, which simulates the tx and returns errors, unlike eth_send which
+        // executes without returning errors or output from the contract.
+        // Note: if this fails and this is the first state update, make sure to set the previous
+        // block number as 1 and the previous block hash as 0, as documented in the contract
+        // initializer.
+        self.ethereum_base_layer
+            .contract
+            .updateState(output.clone(), Default::default())
+            .call()
+            .await?;
+
+        self.ethereum_base_layer
+            .contract
+            .updateState(output, Default::default())
+            .send()
+            .await
+            .unwrap()
+            .get_receipt()
+            .await
+            .unwrap();
+
+        Ok(())
+    }
+
+    /// Initialize the mocked Starknet contract with default test values and first block number and
+    /// hash as 1.
+    ///
+    /// Other values are boilerplate to match the offsets in the Starknet solidity contract, a
+    /// better mock can remove those as well.
+    /// NOTE: right now this is coupled with the conditionally compiled mocked starknet account at
+    /// EthereumBaseLayer; It'd be best if it could be included here instead, but this seems
+    /// nontrivial without duplicating EthereumBaseLayer, which is self-defeating for a test.
+    async fn initialize_mocked_starknet_contract(&self) {
+        let init_data = InitializeData {
+            programHash: U256::from(1),
+            configHash: U256::from(1),
+            initialState: StateUpdate {
+                blockNumber: I256::from_dec_str("1").unwrap(),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let encoded_data = init_data.abi_encode();
+        let builder = self.ethereum_base_layer.contract.initializeMock(encoded_data.into());
+        builder.send().await.unwrap().get_receipt().await.unwrap();
+    }
 }
 
 #[async_trait]
@@ -198,3 +263,47 @@ pub async fn send_message_to_l2(
         // Waits until the transaction is received on L1 and then fetches its receipt.
         .get_receipt().await.expect("Transaction was not received on L1 or receipt retrieval failed.")
 }
+
+pub struct MockedStateUpdate {
+    pub new_block_number: u64,
+    pub new_block_hash: u64,
+    // Consider caching and auto-filling this for better UX.
+    pub prev_block_hash: u64,
+}
+
+// The following structures are used with a mocked version of the Starknet L1 contract.
+// This mocked contract (starknet_for_testing.json) differs from the production contract:
+// - Includes an `initializeMock` function that bypasses governance requirements.
+// - The `updateState` function doesn't require special permissions.
+// - Removed a bunch of checks and functionality not necessary and that was difficult to mock,and
+//   that are not called from the sequencer at this time.
+// - Used exclusively for integration testing with Anvil.
+sol! {
+    #[derive(Debug, Default)]
+    struct StateUpdate {
+        uint256 globalRoot;
+        int256 blockNumber;
+        uint256 blockHash;
+    }
+
+    #[derive(Debug, Default)]
+    struct InitializeData {
+        uint256 programHash;
+        uint256 aggregatorProgramHash;
+        address verifier;
+        uint256 configHash;
+        StateUpdate initialState;
+    }
+}
+
+/// Output offsets from the Starknet solidity contract. These correspond to `StarknetOutput`,
+/// defined in the public `Output.sol` contract. These are the only offsets for values currently
+/// used in the starknet contract mock, if more are needed, which isn't likely, grab the offsets
+/// from Output.sol.
+mod starknet_output {
+    pub const PREV_BLOCK_NUMBER_OFFSET: usize = 2;
+    pub const NEW_BLOCK_NUMBER_OFFSET: usize = 3;
+    pub const PREV_BLOCK_HASH_OFFSET: usize = 4;
+    pub const NEW_BLOCK_HASH_OFFSET: usize = 5;
+    pub const HEADER_SIZE: usize = 10;
+}

crates/apollo_integration_tests/tests/l1_events_scraper_end_to_end.rs

@@ -37,27 +37,35 @@ async fn scraper_end_to_end() {
     // Send messages from L1 to L2.
     let l2_contract_address = "0x12";
     let l2_entry_point = "0x34";
-    let message_to_l2_0 = contract.sendMessageToL2(
-        l2_contract_address.parse().unwrap(),
-        l2_entry_point.parse().unwrap(),
-        vec![U256::from(1_u8), U256::from(2_u8)],
-    );
-    let message_to_l2_1 = contract.sendMessageToL2(
-        l2_contract_address.parse().unwrap(),
-        l2_entry_point.parse().unwrap(),
-        vec![U256::from(3_u8), U256::from(4_u8)],
-    );
+    let fee = 1_u8;
+    let message_to_l2_0 = contract
+        .sendMessageToL2(
+            l2_contract_address.parse().unwrap(),
+            l2_entry_point.parse().unwrap(),
+            vec![U256::from(1_u8), U256::from(2_u8)],
+        )
+        .value(U256::from(fee));
+    let message_to_l2_1 = contract
+        .sendMessageToL2(
+            l2_contract_address.parse().unwrap(),
+            l2_entry_point.parse().unwrap(),
+            vec![U256::from(3_u8), U256::from(4_u8)],
+        )
+        .value(U256::from(fee));
     let nonce_of_message_to_l2_0 = U256::from(0_u8);
-    let request_cancel_message_0 = contract.startL1ToL2MessageCancellation(
-        l2_contract_address.parse().unwrap(),
-        l2_entry_point.parse().unwrap(),
-        vec![U256::from(1_u8), U256::from(2_u8)],
-        nonce_of_message_to_l2_0,
-    );
+    let request_cancel_message_0 = contract
+        .startL1ToL2MessageCancellation(
+            l2_contract_address.parse().unwrap(),
+            l2_entry_point.parse().unwrap(),
+            vec![U256::from(1_u8), U256::from(2_u8)],
+            nonce_of_message_to_l2_0,
+        )
+        .from(DEFAULT_ANVIL_L1_ACCOUNT_ADDRESS.to_hex_string().parse().unwrap());
 
     // Send the transactions to Anvil, and record the timestamps of the blocks they are included in.
     let mut l1_handler_timestamps: Vec<BlockTimestamp> = Vec::with_capacity(2);
     for msg in &[message_to_l2_0, message_to_l2_1] {
+        msg.call().await.unwrap(); // Query for errors.
         let receipt = msg.send().await.unwrap().get_receipt().await.unwrap();
         l1_handler_timestamps.push(
             base_layer
@@ -69,6 +77,7 @@ async fn scraper_end_to_end() {
         );
     }
 
+    request_cancel_message_0.call().await.unwrap(); // Query for errors;
     let cancel_receipt =
         request_cancel_message_0.send().await.unwrap().get_receipt().await.unwrap();
     let cancel_timestamp = base_layer
@@ -95,7 +104,7 @@ async fn scraper_end_to_end() {
     let expected_executable_l1_handler_0 = ExecutableL1HandlerTransaction {
         tx_hash: tx_hash_first_tx,
         tx: expected_l1_handler_0,
-        paid_fee_on_l1: Fee(0),
+        paid_fee_on_l1: Fee(fee.into()),
     };
     let first_expected_log = Event::L1HandlerTransaction {
         l1_handler_tx: expected_executable_l1_handler_0.clone(),

crates/apollo_integration_tests/tests/mocked_starknet_state_update_test.rs

@@ -0,0 +1,90 @@
+use alloy::primitives::{I256, U256};
+use alloy::providers::Provider;
+use alloy::rpc::types::eth::Filter as EthEventFilter;
+use alloy::sol_types::SolEventInterface;
+use apollo_integration_tests::anvil_base_layer::{AnvilBaseLayer, MockedStateUpdate};
+use papyrus_base_layer::ethereum_base_layer_contract::Starknet;
+use papyrus_base_layer::BaseLayerContract;
+use pretty_assertions::assert_eq;
+use starknet_api::block::{BlockHash, BlockHashAndNumber, BlockNumber};
+
+#[tokio::test]
+async fn test_mocked_starknet_state_update() {
+    let base_layer = AnvilBaseLayer::new().await;
+
+    // Check that the contract was initialized (during the construction above).
+    let no_finality = 0;
+    let genesis_block_number = 1;
+    let genesis_block_hash = 0;
+    let initial_state = base_layer.latest_proved_block(no_finality).await.unwrap().unwrap();
+    assert_eq!(
+        initial_state.number,
+        BlockNumber(genesis_block_number),
+        "Starknet contract was not initiailized."
+    );
+    assert_eq!(
+        initial_state.hash,
+        BlockHash(genesis_block_hash.into()),
+        "Starknet contract was not initiailized."
+    );
+
+    // Negative flow: update state should always have sequential block numbers.
+    let wrong_next_block_number = genesis_block_number + 2;
+    let incorrect_new_block_number_result = base_layer
+        .update_mocked_starknet_contract_state(MockedStateUpdate {
+            new_block_number: wrong_next_block_number,
+            new_block_hash: 2,
+            prev_block_hash: genesis_block_hash,
+        })
+        .await;
+    assert!(
+        incorrect_new_block_number_result
+            .unwrap_err()
+            .to_string()
+            .contains("INVALID_PREV_BLOCK_NUMBER")
+    );
+
+    // Happy flow.
+    let next_block_number = genesis_block_number + 1;
+    let new_block_hash = 2;
+    base_layer
+        .update_mocked_starknet_contract_state(MockedStateUpdate {
+            new_block_number: next_block_number,
+            new_block_hash,
+            prev_block_hash: genesis_block_hash,
+        })
+        .await
+        .unwrap();
+
+    let updated_block_number_and_hash =
+        base_layer.latest_proved_block(no_finality).await.unwrap().unwrap();
+    assert_eq!(
+        updated_block_number_and_hash,
+        BlockHashAndNumber {
+            number: BlockNumber(next_block_number),
+            hash: BlockHash(new_block_hash.into())
+        }
+    );
+
+    // Check that LogStateUpdate event was emitted (we don't use this event in the sequencer at the
+    // time this was written).
+    let event = base_layer
+        .ethereum_base_layer
+        .contract
+        .provider()
+        .get_logs(&EthEventFilter::new().from_block(1))
+        .await
+        .unwrap();
+    let event = event.first().unwrap();
+
+    match Starknet::StarknetEvents::decode_log(&event.inner).unwrap().data {
+        Starknet::StarknetEvents::LogStateUpdate(state_update) => {
+            assert_eq!(
+                state_update.blockNumber,
+                I256::from_dec_str(&next_block_number.to_string()).unwrap(),
+            );
+            assert_eq!(state_update.blockHash, U256::from(new_block_hash));
+        }
+        _ => panic!("Expected LogStateUpdate event"),
+    }
+}