1#![cfg_attr(not(feature = "std"), no_std)]
27
28extern crate alloc;
29
30use core::cmp::Ordering;
31use frame_support::{
32 pallet_prelude::*,
33 storage::{transactional::with_transaction_opaque_err, with_storage_layer, TransactionOutcome},
34 traits::{
35 fungible::{InspectHold, MutateHold},
36 tokens::Precision,
37 },
38};
39use hrmp_primitives::{
40 Balance, ChannelId, DepositError, DepositKey, DepositSide, MessageToPara, MessageToParaV1,
41 MessageToRelay, MessageToRelayV1, ParaId, ReceiveMigratedDeposits,
42};
43use sp_runtime::{traits::Convert, DispatchError, DispatchResult, TokenError};
44
45pub use pallet::*;
46pub use weights::WeightInfo;
47
48pub mod weights;
49
50#[cfg(feature = "runtime-benchmarks")]
51mod benchmarking;
52#[cfg(test)]
53mod mock;
54#[cfg(test)]
55mod tests;
56
57pub const RECEIVE_CALL_INDEX: u8 = 0;
59
60pub trait SendToRelay {
62 #[allow(clippy::result_unit_err)]
64 fn send(message: MessageToRelay) -> Result<(), ()>;
65}
66
67#[cfg(feature = "std")]
68impl SendToRelay for () {
69 fn send(_message: MessageToRelay) -> Result<(), ()> {
70 Ok(())
71 }
72}
73
74#[cfg(feature = "runtime-benchmarks")]
76pub trait BenchmarkHelper {
77 fn ensure_send_to_relay();
79}
80
81#[cfg(feature = "runtime-benchmarks")]
82impl BenchmarkHelper for () {
83 fn ensure_send_to_relay() {}
84}
85
86pub type ReasonOf<T> =
88 <<T as Config>::Currency as InspectHold<<T as frame_system::Config>::AccountId>>::Reason;
89
90#[derive(Encode, Decode, Clone, Eq, PartialEq, Debug, TypeInfo, MaxEncodedLen)]
92pub struct Deposit<AccountId> {
93 pub amount: Balance,
95 pub depositor: AccountId,
100}
101
102#[frame_support::pallet]
103pub mod pallet {
104 use super::*;
105 use frame_system::pallet_prelude::*;
106
107 #[pallet::config]
108 pub trait Config: frame_system::Config {
109 type Currency: MutateHold<Self::AccountId, Reason: From<HoldReason>, Balance = Balance>;
111
112 type SendToRelay: SendToRelay;
114
115 type SovereignAccountOf: Convert<ParaId, Self::AccountId>;
121
122 type WeightInfo: WeightInfo;
124
125 #[cfg(feature = "runtime-benchmarks")]
127 type BenchmarkHelper: BenchmarkHelper;
128 }
129
130 #[pallet::pallet]
131 pub struct Pallet<T>(_);
132
133 #[pallet::composite_enum]
135 pub enum HoldReason {
136 #[codec(index = 0)]
138 ChannelDeposit,
139 }
140
141 #[pallet::storage]
145 pub type Deposits<T: Config> =
146 StorageMap<_, Twox64Concat, (ChannelId, DepositSide), Deposit<T::AccountId>, OptionQuery>;
147
148 #[pallet::event]
149 #[pallet::generate_deposit(pub(super) fn deposit_event)]
150 pub enum Event<T: Config> {
151 DepositSet { channel: ChannelId, side: DepositSide, amount: Balance },
153 DepositRefused { id: u64, channel: ChannelId },
155 DepositMigrated { channel: ChannelId, side: DepositSide, amount: Balance, held: Balance },
158 }
159
160 #[pallet::error]
161 pub enum Error<T> {
162 SendFailed,
164 InsufficientFunds,
166 CannotChangeDeposit,
168 }
169
170 #[pallet::hooks]
171 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
172 #[cfg(feature = "try-runtime")]
173 fn try_state(_: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
174 Self::do_try_state()
175 }
176 }
177
178 #[pallet::call]
179 impl<T: Config> Pallet<T> {
180 #[pallet::call_index(0)]
185 #[pallet::weight(match message {
186 MessageToPara::V1(MessageToParaV1::SetDeposits { .. }) =>
187 T::WeightInfo::receive_set_deposits(),
188 MessageToPara::V1(MessageToParaV1::Release { .. }) => T::WeightInfo::receive_release(),
189 })]
190 pub fn receive(origin: OriginFor<T>, message: MessageToPara) -> DispatchResult {
191 ensure_root(origin)?;
192
193 match message {
194 MessageToPara::V1(MessageToParaV1::SetDeposits {
195 id,
196 channel,
197 sender,
198 recipient,
199 }) => {
200 let result = with_transaction_opaque_err(|| {
201 if let Some(target) = sender {
202 if let Err(err) = Self::set_side(channel, DepositSide::Sender, target) {
203 return TransactionOutcome::Rollback(Err(err));
204 }
205 }
206 if let Some(target) = recipient {
207 if let Err(err) =
208 Self::set_side(channel, DepositSide::Recipient, target)
209 {
210 return TransactionOutcome::Rollback(Err(err));
211 }
212 }
213
214 TransactionOutcome::Commit(Ok(()))
215 })
216 .unwrap_or(Err(DepositError::Other)); if result.is_err() {
219 Self::deposit_event(Event::DepositRefused { id, channel });
220 }
221 Self::send(MessageToRelayV1::DepositsSet { id, result })
222 },
223 MessageToPara::V1(MessageToParaV1::Release { channel, sender, recipient }) => {
224 if sender {
225 Self::release_side(channel, DepositSide::Sender);
226 }
227 if recipient {
228 Self::release_side(channel, DepositSide::Recipient);
229 }
230 Ok(())
231 },
232 }
233 }
234
235 #[pallet::call_index(1)]
238 #[pallet::weight(T::WeightInfo::receive_set_deposits())]
239 pub fn force_set_deposit(
240 origin: OriginFor<T>,
241 channel: ChannelId,
242 side: DepositSide,
243 amount: Balance,
244 ) -> DispatchResult {
245 ensure_root(origin)?;
246
247 if Deposits::<T>::get((channel, side)).map_or(0, |d| d.amount) == amount {
248 return Ok(());
249 }
250 Self::set_side(channel, side, amount).map_err(|e| match e {
251 DepositError::InsufficientFunds => Error::<T>::InsufficientFunds.into(),
252 DepositError::Other => Error::<T>::CannotChangeDeposit.into(),
253 })
254 }
255 }
256}
257
258impl<T: Config> ReceiveMigratedDeposits<ReasonOf<T>> for Pallet<T> {
259 fn receive_deposit(key: DepositKey, amount: Balance, source: &ReasonOf<T>) -> DispatchResult {
260 let DepositKey { channel, side } = key;
261 let local = HoldReason::ChannelDeposit.into();
262 let (current, who) = match Deposits::<T>::get((channel, side)) {
264 Some(Deposit { amount, depositor }) => (amount, depositor),
265 None => (0, Self::payer(&channel, side)),
266 };
267 let (from, to, wanted) = if amount > current {
270 (source, &local, amount - current)
271 } else {
272 (&local, source, current - amount)
273 };
274
275 let moved = wanted.min(T::Currency::balance_on_hold(from, &who));
276 if moved != 0 {
277 with_storage_layer(|| -> DispatchResult {
279 T::Currency::release(from, &who, moved, Precision::Exact)?;
280 T::Currency::hold(to, &who, moved)
281 })?;
282 }
283 let held = if amount > current {
284 current.saturating_add(moved)
285 } else {
286 current.saturating_sub(moved)
287 };
288
289 if moved != wanted {
290 frame_support::defensive!("hrmp-para: moved holds not as wanted", (wanted, moved));
291 }
292 if held != current {
293 if held == 0 {
294 Deposits::<T>::remove((channel, side));
295 } else {
296 Deposits::<T>::insert((channel, side), Deposit { amount: held, depositor: who });
297 }
298 Self::deposit_event(Event::DepositSet { channel, side, amount: held });
299 }
300 Self::deposit_event(Event::DepositMigrated { channel, side, amount, held });
301 Ok(())
302 }
303
304 fn weight_of_receive_deposit() -> Weight {
305 T::WeightInfo::receive_deposit()
306 }
307}
308
309impl<T: Config> Pallet<T> {
310 fn payer(channel: &ChannelId, side: DepositSide) -> T::AccountId {
312 T::SovereignAccountOf::convert(side.para(channel))
313 }
314
315 fn send(message: MessageToRelayV1) -> DispatchResult {
316 T::SendToRelay::send(MessageToRelay::V1(message))
317 .map_err(|()| Error::<T>::SendFailed.into())
318 }
319
320 fn set_side(
322 channel: ChannelId,
323 side: DepositSide,
324 target: Balance,
325 ) -> Result<(), DepositError> {
326 let reason = HoldReason::ChannelDeposit.into();
327 let (held, who) = match Deposits::<T>::get((channel, side)) {
328 Some(Deposit { amount, depositor }) => (amount, depositor),
329 None => (0, Self::payer(&channel, side)),
330 };
331
332 match target.cmp(&held) {
333 Ordering::Greater => {
334 T::Currency::hold(&reason, &who, target - held).map_err(|e| match e {
335 DispatchError::Token(TokenError::FundsUnavailable) => {
336 DepositError::InsufficientFunds
337 },
338 _ => DepositError::Other,
339 })?;
340 },
341 Ordering::Less => {
342 let to_release = held - target;
343 let released =
344 T::Currency::release(&reason, &who, to_release, Precision::BestEffort)
345 .map_err(|_| DepositError::Other)?;
346 if released != to_release {
347 frame_support::defensive!(
348 "hrmp-para: released less than recorded",
349 (to_release, released)
350 );
351 }
352 },
353 Ordering::Equal => {},
354 }
355
356 if target == 0 {
357 Deposits::<T>::remove((channel, side));
358 } else {
359 Deposits::<T>::insert((channel, side), Deposit { amount: target, depositor: who });
360 }
361 Self::deposit_event(Event::DepositSet { channel, side, amount: target });
362 Ok(())
363 }
364
365 fn release_side(channel: ChannelId, side: DepositSide) {
369 let Some(Deposit { amount: held, depositor: who }) = Deposits::<T>::take((channel, side))
370 else {
371 return;
372 };
373 let reason = HoldReason::ChannelDeposit.into();
374
375 let released =
376 T::Currency::release(&reason, &who, held, Precision::BestEffort).unwrap_or_default();
377 if released != held {
378 frame_support::defensive!("hrmp-para: released less than recorded", (held, released));
379 }
380
381 Self::deposit_event(Event::DepositSet { channel, side, amount: 0 });
382 }
383
384 #[cfg(any(feature = "try-runtime", test))]
386 pub fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
387 use alloc::collections::btree_map::BTreeMap;
388 let mut per_depositor = BTreeMap::<T::AccountId, Balance>::new();
389
390 for (_, Deposit { amount, depositor }) in Deposits::<T>::iter() {
391 ensure!(amount != 0, "hrmp-para: a side holding nothing is recorded");
392 let total = per_depositor.entry(depositor).or_default();
393 *total = total.saturating_add(amount);
394 }
395
396 for (depositor, recorded) in per_depositor {
397 let on_hold =
398 T::Currency::balance_on_hold(&HoldReason::ChannelDeposit.into(), &depositor);
399 ensure!(on_hold == recorded, "hrmp-para: a depositor's hold differs from its deposits");
400 }
401
402 Ok(())
403 }
404}