feat: test pallet check with Alice balance

Author: metricaez

Cargo.lock

@@ -17,6 +17,8 @@ codec = { features = ["derive"], workspace = true }
 # Substrate
 sp-consensus-babe = { workspace = true }
 sp-core = { workspace = true }
+sp-io = { workspace = true }
+sp-keyring = { workspace = true }
 sp-runtime = { workspace = true }
 sp-state-machine = { workspace = true }
 sp-trie = { workspace = true }
@@ -38,6 +40,8 @@ std = [
 	"polkadot-primitives/std",
 	"sp-consensus-babe/std",
 	"sp-core/std",
+	"sp-io/std",
+	"sp-keyring/std",
 	"sp-runtime/std",
 	"sp-state-machine/std",
 	"sp-trie/std",

cumulus/test/relay-sproof-builder/Cargo.toml

@@ -247,6 +247,9 @@ impl RelayStateSproofBuilder {
 			);
 			insert(relay_chain::well_known_keys::CURRENT_SLOT.to_vec(), self.current_slot.encode());
 
+			let (alice_key, alice_data) = generate_alice_account();
+			insert(alice_key, alice_data);
+
 			for (key, value) in self.additional_key_values {
 				insert(key, value);
 			}
@@ -273,6 +276,21 @@ fn convert_to_authority_weight_pair(
 		.collect()
 }
 
+/// Include to avoid `KeyToIncludeInRelayProof` test on test-pallet to break unit tests.
+fn generate_alice_account() -> (Vec<u8>, Vec<u8>) {
+	use codec::Encode;
+	use sp_keyring::Sr25519Keyring;
+
+	let alice = Sr25519Keyring::Alice.to_account_id();
+	let mut alice_key = sp_io::hashing::twox_128(b"System").to_vec();
+	alice_key.extend_from_slice(&sp_io::hashing::twox_128(b"Account"));
+	alice_key.extend_from_slice(&sp_io::hashing::blake2_128(&alice.encode()));
+	alice_key.extend_from_slice(&alice.encode());
+
+	let alice_account = (0u32, 0u32, 1u32, 0u32, 25_000_000_000_000u128, 0u128, 0u128, 0u128);
+	(alice_key, alice_account.encode())
+}
+
 /// Add a BABE pre-digest to a generic header
 fn add_babe_pre_digest(header: &mut Header, authority_index: u32, block_number: u64) {
 	/// This method generates some vrf data, but only to make the compiler happy

cumulus/test/relay-sproof-builder/src/lib.rs

@@ -648,8 +648,8 @@ impl_runtime_apis! {
 
 			RelayProofRequest {
 				keys: vec![
-					// Request a well-known key to verify its inclusion in the relay proof.
-					RelayStorageKey::Top(test_pallet::RELAY_EPOCH_INDEX_KEY.to_vec()),
+					// Request a key to verify its inclusion in the proof.
+					RelayStorageKey::Top(test_pallet::relay_alice_account_key()),
 				],
 			}
 		}

cumulus/test/runtime/src/lib.rs

@@ -17,14 +17,24 @@
 /// A special pallet that exposes dispatchables that are only useful for testing.
 pub use pallet::*;
 
-use polkadot_primitives::well_known_keys;
+use codec::Encode;
 
 /// Some key that we set in genesis and only read in [`TestOnRuntimeUpgrade`] to ensure that
 /// [`OnRuntimeUpgrade`] works as expected.
 pub const TEST_RUNTIME_UPGRADE_KEY: &[u8] = b"+test_runtime_upgrade_key+";
 
-/// A well-known key to request for inclusion in the proof.
-pub use well_known_keys::EPOCH_INDEX as RELAY_EPOCH_INDEX_KEY;
+/// Generates the storage key for Alice's account on the relay chain.
+pub fn relay_alice_account_key() -> alloc::vec::Vec<u8> {
+	use sp_keyring::Sr25519Keyring;
+
+	let alice = Sr25519Keyring::Alice.to_account_id();
+
+	let mut key = sp_io::hashing::twox_128(b"System").to_vec();
+	key.extend_from_slice(&sp_io::hashing::twox_128(b"Account"));
+	key.extend_from_slice(&sp_io::hashing::blake2_128(&alice.encode()));
+	key.extend_from_slice(&alice.encode());
+	key
+}
 
 #[frame_support::pallet(dev_mode)]
 pub mod pallet {
@@ -139,13 +149,17 @@ impl<T: Config> cumulus_pallet_parachain_system::OnSystemEvent for Pallet<T> {
 	fn on_relay_state_proof(
 		relay_state_proof: &cumulus_pallet_parachain_system::relay_state_snapshot::RelayChainStateProof,
 	) -> frame_support::weights::Weight {
-		use crate::test_pallet::RELAY_EPOCH_INDEX_KEY;
+		use crate::{Balance, Nonce};
+		use frame_system::AccountInfo;
+		use pallet_balances::AccountData;
+
+		let alice_key = crate::test_pallet::relay_alice_account_key();
 
-		// Expect the requested key to be part of the proof.
+		// Verify that Alice's account is included in the relay proof.
 		relay_state_proof
-			.read_optional_entry::<u64>(RELAY_EPOCH_INDEX_KEY)
+			.read_optional_entry::<AccountInfo<Nonce, AccountData<Balance>>>(&alice_key)
 			.expect("Invalid relay chain state proof")
-			.expect("EPOCH_INDEX must be present");
+			.expect("Alice's account must be present in the relay proof");
 
 		frame_support::weights::Weight::zero()
 	}