1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::common::{ToStateChange, Types, TypesAndLimits};

use super::{Action, ActionWithNonce};
use codec::{Decode, Encode};

/// Wraps any value in an action with the given target.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, scale_info_derive::TypeInfo)]
#[scale_info(omit_prefix)]
pub struct ActionWrapper<A, Ta> {
    pub target: Ta,
    pub action: A,
}

impl<A, Ta> ActionWrapper<A, Ta> {
    /// Wraps any value in an action with the supplied nonce and given target.
    pub fn new(target: Ta, action: A) -> Self {
        Self { target, action }
    }

    /// Wraps given function producing a function that takes `ActionWrapper` as a parameter.
    pub fn wrap_fn<V, O, F: FnOnce(A, V) -> O>(f: F) -> impl FnOnce(Self, V) -> O {
        move |Self { action, .. }, value| f(action, value)
    }
}

impl<A: Action, Ta: Clone> Action for ActionWrapper<A, Ta> {
    type Target = Ta;

    fn target(&self) -> Self::Target {
        self.target.clone()
    }

    fn len(&self) -> u32 {
        self.action.len()
    }
}

impl<T: TypesAndLimits, A: Action, Ta: Clone> ToStateChange<T> for ActionWrapper<A, Ta>
where
    A: ToStateChange<T>,
{
    fn to_state_change(&self) -> crate::common::StateChange<'_, T> {
        self.action.to_state_change()
    }
}

/// Wraps any value in an action with the supplied nonce and given target.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, scale_info_derive::TypeInfo)]
#[scale_info(omit_prefix)]
pub struct ActionWithNonceWrapper<T: Types, A, Ta> {
    pub action: A,
    pub nonce: T::BlockNumber,
    pub target: Ta,
}

impl<T: Types, A, Ta> ActionWithNonceWrapper<T, A, Ta> {
    /// Wraps any value in an action with the supplied nonce and given target.
    pub fn new(nonce: T::BlockNumber, target: Ta, action: A) -> Self {
        Self {
            nonce,
            target,
            action,
        }
    }

    /// Wraps given function producing a function that takes `ActionWithNonceWrapper` as a parameter.
    pub fn wrap_fn<V, O, F: FnOnce(A, &mut V, Ta) -> O>(
        f: F,
    ) -> impl FnOnce(Self, &mut V, Ta) -> O {
        move |Self { action, .. }, value, target| f(action, value, target)
    }
}

impl<T: Types, A: Action, Ta: Clone> Action for ActionWithNonceWrapper<T, A, Ta> {
    type Target = Ta;

    fn target(&self) -> Self::Target {
        self.target.clone()
    }

    fn len(&self) -> u32 {
        self.action.len()
    }
}

impl<T: Types, A: Action, Ta: Clone> ActionWithNonce<T> for ActionWithNonceWrapper<T, A, Ta> {
    fn nonce(&self) -> T::BlockNumber {
        self.nonce
    }
}

impl<T: TypesAndLimits, A: Action, Ta: Clone> ToStateChange<T> for ActionWithNonceWrapper<T, A, Ta>
where
    A: ToStateChange<T>,
{
    fn to_state_change(&self) -> crate::common::StateChange<'_, T> {
        self.action.to_state_change()
    }
}