pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-31 16:51:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename pallet-message-lane into pallet-bridge-messages (#834)

Browse Source 
* use runtime:: prefix for message-lane pallet traces

* renamed message-lane (module and primitives) folder into messages

* replace "message lane" with "messages" where appropriate
This commit is contained in:
Svyatoslav Nikolsky
2021-03-22 19:28:31 +03:00
committed by Bastian Köcher
parent eb7c96ba14
commit 4105575794
72 changed files with 492 additions and 471 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bridges/bin/rialto/runtime/src/millau_messages.rs
+24 -24
View File
@@ -14,17 +14,17 @@
// 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/>.
//! Everything required to serve Millau <-> Rialto message lanes.
//! Everything required to serve Millau <-> Rialto messages.
use crate::Runtime;
use bp_message_lane::{
use bp_messages::{
source_chain::TargetHeaderChain,
target_chain::{ProvedMessages, SourceHeaderChain},
InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessageLaneParameter,
InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessagesParameter,
};
use bp_runtime::{InstanceId, MILLAU_BRIDGE_INSTANCE};
use bridge_runtime_common::messages::{self, ChainWithMessageLanes, MessageBridge, MessageLaneTransaction};
use bridge_runtime_common::messages::{self, ChainWithMessages, MessageBridge, MessageTransaction};
use codec::{Decode, Encode};
use frame_support::{
parameter_types,
@@ -42,23 +42,23 @@ parameter_types! {
/// Storage key of the Rialto -> Millau message in the runtime storage.
pub fn message_key(lane: &LaneId, nonce: MessageNonce) -> StorageKey {
pallet_message_lane::storage_keys::message_key::<Runtime, <Rialto as ChainWithMessageLanes>::MessageLaneInstance>(
pallet_bridge_messages::storage_keys::message_key::<Runtime, <Rialto as ChainWithMessages>::MessagesInstance>(
lane, nonce,
)
}
/// Storage key of the Rialto -> Millau message lane state in the runtime storage.
pub fn outbound_lane_data_key(lane: &LaneId) -> StorageKey {
pallet_message_lane::storage_keys::outbound_lane_data_key::<<Rialto as ChainWithMessageLanes>::MessageLaneInstance>(
pallet_bridge_messages::storage_keys::outbound_lane_data_key::<<Rialto as ChainWithMessages>::MessagesInstance>(
lane,
)
}
/// Storage key of the Millau -> Rialto message lane state in the runtime storage.
pub fn inbound_lane_data_key(lane: &LaneId) -> StorageKey {
pallet_message_lane::storage_keys::inbound_lane_data_key::<
pallet_bridge_messages::storage_keys::inbound_lane_data_key::<
Runtime,
<Rialto as ChainWithMessageLanes>::MessageLaneInstance,
<Rialto as ChainWithMessages>::MessagesInstance,
>(lane)
}
@@ -109,7 +109,7 @@ impl MessageBridge for WithMillauMessageBridge {
#[derive(RuntimeDebug, Clone, Copy)]
pub struct Rialto;
impl messages::ChainWithMessageLanes for Rialto {
impl messages::ChainWithMessages for Rialto {
type Hash = bp_rialto::Hash;
type AccountId = bp_rialto::AccountId;
type Signer = bp_rialto::AccountSigner;
@@ -117,10 +117,10 @@ impl messages::ChainWithMessageLanes for Rialto {
type Weight = Weight;
type Balance = bp_rialto::Balance;
type MessageLaneInstance = crate::WithMillauMessageLaneInstance;
type MessagesInstance = crate::WithMillauMessagesInstance;
}
impl messages::ThisChainWithMessageLanes for Rialto {
impl messages::ThisChainWithMessages for Rialto {
type Call = crate::Call;
fn is_outbound_lane_enabled(lane: &LaneId) -> bool {
@@ -131,12 +131,12 @@ impl messages::ThisChainWithMessageLanes for Rialto {
MessageNonce::MAX
}
fn estimate_delivery_confirmation_transaction() -> MessageLaneTransaction<Weight> {
fn estimate_delivery_confirmation_transaction() -> MessageTransaction<Weight> {
let inbound_data_size =
InboundLaneData::<bp_rialto::AccountId>::encoded_size_hint(bp_rialto::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE, 1)
.unwrap_or(u32::MAX);
MessageLaneTransaction {
MessageTransaction {
dispatch_weight: bp_rialto::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT,
size: inbound_data_size
.saturating_add(bp_millau::EXTRA_STORAGE_PROOF_SIZE)
@@ -144,7 +144,7 @@ impl messages::ThisChainWithMessageLanes for Rialto {
}
}
fn transaction_payment(transaction: MessageLaneTransaction<Weight>) -> bp_rialto::Balance {
fn transaction_payment(transaction: MessageTransaction<Weight>) -> bp_rialto::Balance {
// in our testnets, both per-byte fee and weight-to-fee are 1:1
messages::transaction_payment(
bp_rialto::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
@@ -160,7 +160,7 @@ impl messages::ThisChainWithMessageLanes for Rialto {
#[derive(RuntimeDebug, Clone, Copy)]
pub struct Millau;
impl messages::ChainWithMessageLanes for Millau {
impl messages::ChainWithMessages for Millau {
type Hash = bp_millau::Hash;
type AccountId = bp_millau::AccountId;
type Signer = bp_millau::AccountSigner;
@@ -168,10 +168,10 @@ impl messages::ChainWithMessageLanes for Millau {
type Weight = Weight;
type Balance = bp_millau::Balance;
type MessageLaneInstance = pallet_message_lane::DefaultInstance;
type MessagesInstance = pallet_bridge_messages::DefaultInstance;
}
impl messages::BridgedChainWithMessageLanes for Millau {
impl messages::BridgedChainWithMessages for Millau {
fn maximal_extrinsic_size() -> u32 {
bp_millau::max_extrinsic_size()
}
@@ -191,12 +191,12 @@ impl messages::BridgedChainWithMessageLanes for Millau {
fn estimate_delivery_transaction(
message_payload: &[u8],
message_dispatch_weight: Weight,
) -> MessageLaneTransaction<Weight> {
) -> MessageTransaction<Weight> {
let message_payload_len = u32::try_from(message_payload.len()).unwrap_or(u32::MAX);
let extra_bytes_in_payload = Weight::from(message_payload_len)
.saturating_sub(pallet_message_lane::EXPECTED_DEFAULT_MESSAGE_LENGTH.into());
.saturating_sub(pallet_bridge_messages::EXPECTED_DEFAULT_MESSAGE_LENGTH.into());
MessageLaneTransaction {
MessageTransaction {
dispatch_weight: extra_bytes_in_payload
.saturating_mul(bp_millau::ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT)
.saturating_add(bp_millau::DEFAULT_MESSAGE_DELIVERY_TX_WEIGHT)
@@ -207,7 +207,7 @@ impl messages::BridgedChainWithMessageLanes for Millau {
}
}
fn transaction_payment(transaction: MessageLaneTransaction<Weight>) -> bp_millau::Balance {
fn transaction_payment(transaction: MessageTransaction<Weight>) -> bp_millau::Balance {
// in our testnets, both per-byte fee and weight-to-fee are 1:1
messages::transaction_payment(
bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
@@ -257,15 +257,15 @@ impl SourceHeaderChain<bp_millau::Balance> for Millau {
/// Rialto -> Millau message lane pallet parameters.
#[derive(RuntimeDebug, Clone, Encode, Decode, PartialEq, Eq)]
pub enum RialtoToMillauMessageLaneParameter {
pub enum RialtoToMillauMessagesParameter {
/// The conversion formula we use is: `RialtoTokens = MillauTokens * conversion_rate`.
MillauToRialtoConversionRate(FixedU128),
}
impl MessageLaneParameter for RialtoToMillauMessageLaneParameter {
impl MessagesParameter for RialtoToMillauMessagesParameter {
fn save(&self) {
match *self {
RialtoToMillauMessageLaneParameter::MillauToRialtoConversionRate(ref conversion_rate) => {
RialtoToMillauMessagesParameter::MillauToRialtoConversionRate(ref conversion_rate) => {
MillauToRialtoConversionRate::set(conversion_rate)
}
}