fix: Complete snowbridge pezpallet rebrand and critical bug fixes

- snowbridge-pezpallet-* → pezsnowbridge-pezpallet-* (201 refs) - pallet/ directories → pezpallet/ (4 locations) - Fixed pezpallet.rs self-include recursion bug - Fixed sc-chain-spec hardcoded crate name in derive macro - Reverted .pezpallet_by_name() to .pallet_by_name() (subxt API) - Added BizinikiwiConfig type alias for zombienet tests - Deleted obsolete session state files Verified: pezsnowbridge-pezpallet-*, pezpallet-staking, pezpallet-staking-async, pezframe-benchmarking-cli all pass cargo check
2025-12-16 09:57:23 +03:00
parent eea003e14d
commit 3139ffa25e
3022 changed files with 42157 additions and 23579 deletions
@@ -0,0 +1,210 @@
+// Copyright (C) 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/>.
+
+//! Primitives of teyrchains module.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use bp_header_pez_chain::StoredHeaderData;
+pub use call_info::{BridgeTeyrchainCall, SubmitTeyrchainHeadsInfo};
+
+use bp_pezkuwi_core::teyrchains::{ParaHash, ParaHead, ParaId};
+use pezbp_runtime::{
+	BlockNumberOf, Chain, HashOf, HeaderOf, StorageDoubleMapKeyProvider, StorageMapKeyProvider,
+	Teyrchain,
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use pezframe_support::{weights::Weight, Blake2_128Concat, Twox64Concat};
+use scale_info::TypeInfo;
+use pezsp_core::storage::StorageKey;
+use pezsp_runtime::{traits::Header as HeaderT, RuntimeDebug};
+use pezsp_std::{marker::PhantomData, prelude::*};
+
+/// Block hash of the bridged relay chain.
+pub type RelayBlockHash = bp_pezkuwi_core::Hash;
+/// Block number of the bridged relay chain.
+pub type RelayBlockNumber = bp_pezkuwi_core::BlockNumber;
+/// Hasher of the bridged relay chain.
+pub type RelayBlockHasher = bp_pezkuwi_core::Hasher;
+
+mod call_info;
+
+/// Best known teyrchain head hash.
+#[derive(Clone, Decode, Encode, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct BestParaHeadHash {
+	/// Number of relay block where this head has been read.
+	///
+	/// Teyrchain head is opaque to relay chain. So we can't simply decode it as a header of
+	/// teyrchains and call `block_number()` on it. Instead, we're using the fact that teyrchain
+	/// head is always built on top of previous head (because it is blockchain) and relay chain
+	/// always imports teyrchain heads in order. What it means for us is that at any given
+	/// **finalized** relay block `B`, head of teyrchain will be ancestor (or the same) of all
+	/// teyrchain heads available at descendants of `B`.
+	pub at_relay_block_number: RelayBlockNumber,
+	/// Hash of teyrchain head.
+	pub head_hash: ParaHash,
+}
+
+/// Best known teyrchain head as it is stored in the runtime storage.
+#[derive(Decode, Encode, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct ParaInfo {
+	/// Best known teyrchain head hash.
+	pub best_head_hash: BestParaHeadHash,
+	/// Current ring buffer position for this teyrchain.
+	pub next_imported_hash_position: u32,
+}
+
+/// Returns runtime storage key of given teyrchain head at the source chain.
+///
+/// The head is stored by the `paras` pezpallet in the `Heads` map.
+pub fn teyrchain_head_storage_key_at_source(
+	paras_pallet_name: &str,
+	para_id: ParaId,
+) -> StorageKey {
+	pezbp_runtime::storage_map_final_key::<Twox64Concat>(paras_pallet_name, "Heads", &para_id.encode())
+}
+
+/// Can be use to access the runtime storage key of the teyrchains info at the target chain.
+///
+/// The info is stored by the `pezpallet-bridge-teyrchains` pezpallet in the `ParasInfo` map.
+pub struct ParasInfoKeyProvider;
+impl StorageMapKeyProvider for ParasInfoKeyProvider {
+	const MAP_NAME: &'static str = "ParasInfo";
+
+	type Hasher = Blake2_128Concat;
+	type Key = ParaId;
+	type Value = ParaInfo;
+}
+
+/// Can be use to access the runtime storage key of the teyrchain head at the target chain.
+///
+/// The head is stored by the `pezpallet-bridge-teyrchains` pezpallet in the `ImportedParaHeads` map.
+pub struct ImportedParaHeadsKeyProvider;
+impl StorageDoubleMapKeyProvider for ImportedParaHeadsKeyProvider {
+	const MAP_NAME: &'static str = "ImportedParaHeads";
+
+	type Hasher1 = Blake2_128Concat;
+	type Key1 = ParaId;
+	type Hasher2 = Blake2_128Concat;
+	type Key2 = ParaHash;
+	type Value = ParaStoredHeaderData;
+}
+
+/// Stored data of the teyrchain head. It is encoded version of the
+/// `pezbp_runtime::StoredHeaderData` structure.
+///
+/// We do not know exact structure of the teyrchain head, so we always store encoded version
+/// of the `pezbp_runtime::StoredHeaderData`. It is only decoded when we talk about specific teyrchain.
+#[derive(Clone, Decode, Encode, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct ParaStoredHeaderData(pub Vec<u8>);
+
+impl ParaStoredHeaderData {
+	/// Decode stored teyrchain head data.
+	pub fn decode_teyrchain_head_data<C: Chain>(
+		&self,
+	) -> Result<StoredHeaderData<BlockNumberOf<C>, HashOf<C>>, codec::Error> {
+		StoredHeaderData::<BlockNumberOf<C>, HashOf<C>>::decode(&mut &self.0[..])
+	}
+}
+
+/// Stored teyrchain head data builder.
+pub trait ParaStoredHeaderDataBuilder {
+	/// Maximal teyrchain head size that we may accept for free. All heads above
+	/// this limit are submitted for a regular fee.
+	fn max_free_head_size() -> u32;
+
+	/// Return number of teyrchains that are supported by this builder.
+	fn supported_teyrchains() -> u32;
+
+	/// Try to build head data from encoded head of teyrchain with given id.
+	fn try_build(para_id: ParaId, para_head: &ParaHead) -> Option<ParaStoredHeaderData>;
+}
+
+/// Helper for using single teyrchain as `ParaStoredHeaderDataBuilder`.
+pub struct SingleParaStoredHeaderDataBuilder<C: Teyrchain>(PhantomData<C>);
+
+impl<C: Teyrchain> ParaStoredHeaderDataBuilder for SingleParaStoredHeaderDataBuilder<C> {
+	fn max_free_head_size() -> u32 {
+		C::MAX_HEADER_SIZE
+	}
+
+	fn supported_teyrchains() -> u32 {
+		1
+	}
+
+	fn try_build(para_id: ParaId, para_head: &ParaHead) -> Option<ParaStoredHeaderData> {
+		if para_id == ParaId(C::TEYRCHAIN_ID) {
+			let header = HeaderOf::<C>::decode(&mut &para_head.0[..]).ok()?;
+			return Some(ParaStoredHeaderData(
+				StoredHeaderData { number: *header.number(), state_root: *header.state_root() }
+					.encode(),
+			));
+		}
+		None
+	}
+}
+
+// Tries to build header data from each tuple member, short-circuiting on first successful one.
+#[impl_trait_for_tuples::impl_for_tuples(1, 30)]
+#[tuple_types_custom_trait_bound(Teyrchain)]
+impl ParaStoredHeaderDataBuilder for C {
+	fn max_free_head_size() -> u32 {
+		let mut result = 0_u32;
+		for_tuples!( #(
+			result = pezsp_std::cmp::max(
+				result,
+				SingleParaStoredHeaderDataBuilder::<C>::max_free_head_size(),
+			);
+		)* );
+		result
+	}
+
+	fn supported_teyrchains() -> u32 {
+		let mut result = 0;
+		for_tuples!( #(
+			result += SingleParaStoredHeaderDataBuilder::<C>::supported_teyrchains();
+		)* );
+		result
+	}
+
+	fn try_build(para_id: ParaId, para_head: &ParaHead) -> Option<ParaStoredHeaderData> {
+		for_tuples!( #(
+			let maybe_para_head = SingleParaStoredHeaderDataBuilder::<C>::try_build(para_id, para_head);
+			if let Some(maybe_para_head) = maybe_para_head {
+				return Some(maybe_para_head);
+			}
+		)* );
+
+		None
+	}
+}
+
+/// Runtime hook for when a teyrchain head is updated.
+pub trait OnNewHead {
+	/// Called when a teyrchain head is updated.
+	/// Returns the weight consumed by this function.
+	fn on_new_head(id: ParaId, head: &ParaHead) -> Weight;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(8)]
+impl OnNewHead for Tuple {
+	fn on_new_head(id: ParaId, head: &ParaHead) -> Weight {
+		let mut weight: Weight = Default::default();
+		for_tuples!( #( weight.saturating_accrue(Tuple::on_new_head(id, head)); )* );
+		weight
+	}
+}