pezkuwichain
6b597bebcf
- Fix pezpallet-welati EnsureOrigin implementations (3 fixes)
- Remove incorrect #[cfg(not(feature = "runtime-benchmarks"))] blocks
- Affects EnsureSerok, EnsureParlementer, EnsureDiwan
- Fix asset-hub-zagros governance origins macros (2 fixes)
- Remove non-benchmark try_successful_origin from decl_unit_ensures!
- Remove non-benchmark try_successful_origin from decl_ensure!
- Rename snowbridge -> pezsnowbridge for consistency
- Update WORKFLOW_PLAN.md with build status and package names
- Correct package names: pezkuwi-teyrchain-bin, pezstaging-node-cli
- Mark completed builds: pezkuwi, pezkuwi-teyrchain-bin,
pezstaging-node-cli, teyrchain-template-node
99 lines
3.1 KiB
Rust
99 lines
3.1 KiB
Rust
// SPDX-License-Identifier: Apache-2.0
|
|
// SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
|
|
//! Implementation for [`pezsnowbridge_outbound_queue_primitives::v1::SendMessage`]
|
|
use super::*;
|
|
use bridge_hub_common::AggregateMessageOrigin;
|
|
use codec::Encode;
|
|
use pezframe_support::{
|
|
ensure,
|
|
traits::{EnqueueMessage, Get},
|
|
CloneNoBound, PartialEqNoBound, RuntimeDebugNoBound,
|
|
};
|
|
use pezframe_system::unique;
|
|
use pezsnowbridge_core::{ChannelId, PRIMARY_GOVERNANCE_CHANNEL};
|
|
use pezsnowbridge_outbound_queue_primitives::{
|
|
v1::{Fee, Message, QueuedMessage, SendMessage, VersionedQueuedMessage},
|
|
SendError, SendMessageFeeProvider,
|
|
};
|
|
use pezsp_core::H256;
|
|
use pezsp_runtime::BoundedVec;
|
|
|
|
/// The maximal length of an enqueued message, as determined by the MessageQueue pezpallet
|
|
pub type MaxEnqueuedMessageSizeOf<T> =
|
|
<<T as Config>::MessageQueue as EnqueueMessage<AggregateMessageOrigin>>::MaxMessageLen;
|
|
|
|
#[derive(Encode, Decode, CloneNoBound, PartialEqNoBound, RuntimeDebugNoBound)]
|
|
pub struct Ticket<T>
|
|
where
|
|
T: Config,
|
|
{
|
|
pub message_id: H256,
|
|
pub channel_id: ChannelId,
|
|
pub message: BoundedVec<u8, MaxEnqueuedMessageSizeOf<T>>,
|
|
}
|
|
|
|
impl<T> SendMessage for Pezpallet<T>
|
|
where
|
|
T: Config,
|
|
{
|
|
type Ticket = Ticket<T>;
|
|
|
|
fn validate(
|
|
message: &Message,
|
|
) -> Result<(Self::Ticket, Fee<<Self as SendMessageFeeProvider>::Balance>), SendError> {
|
|
// The inner payload should not be too large
|
|
let payload = message.command.abi_encode();
|
|
ensure!(
|
|
payload.len() < T::MaxMessagePayloadSize::get() as usize,
|
|
SendError::MessageTooLarge
|
|
);
|
|
|
|
// Ensure there is a registered channel we can transmit this message on
|
|
ensure!(T::Channels::contains(&message.channel_id), SendError::InvalidChannel);
|
|
|
|
// Generate a unique message id unless one is provided
|
|
let message_id: H256 = message
|
|
.id
|
|
.unwrap_or_else(|| unique((message.channel_id, &message.command)).into());
|
|
|
|
let gas_used_at_most = T::GasMeter::maximum_gas_used_at_most(&message.command);
|
|
let fee = Self::calculate_fee(gas_used_at_most, T::PricingParameters::get());
|
|
|
|
let queued_message: VersionedQueuedMessage = QueuedMessage {
|
|
id: message_id,
|
|
channel_id: message.channel_id,
|
|
command: message.command.clone(),
|
|
}
|
|
.into();
|
|
// The whole message should not be too large
|
|
let encoded = queued_message.encode().try_into().map_err(|_| SendError::MessageTooLarge)?;
|
|
|
|
let ticket = Ticket { message_id, channel_id: message.channel_id, message: encoded };
|
|
|
|
Ok((ticket, fee))
|
|
}
|
|
|
|
fn deliver(ticket: Self::Ticket) -> Result<H256, SendError> {
|
|
let origin = AggregateMessageOrigin::Snowbridge(ticket.channel_id);
|
|
|
|
if ticket.channel_id != PRIMARY_GOVERNANCE_CHANNEL {
|
|
ensure!(!Self::operating_mode().is_halted(), SendError::Halted);
|
|
}
|
|
|
|
let message = ticket.message.as_bounded_slice();
|
|
|
|
T::MessageQueue::enqueue_message(message, origin);
|
|
Self::deposit_event(Event::MessageQueued { id: ticket.message_id });
|
|
Ok(ticket.message_id)
|
|
}
|
|
}
|
|
|
|
impl<T: Config> SendMessageFeeProvider for Pezpallet<T> {
|
|
type Balance = T::Balance;
|
|
|
|
/// The local component of the message processing fees in native currency
|
|
fn local_fee() -> Self::Balance {
|
|
Self::calculate_local_fee()
|
|
}
|
|
}
|