sunshine-util 0.1.1

objects and relationships for sunshine-bounty pallets
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

use codec::{
    Decode,
    Encode,
};
use sp_runtime::RuntimeDebug;
use sp_std::prelude::*;

#[derive(new, PartialEq, Eq, Default, Clone, Encode, Decode, RuntimeDebug)]
pub struct Dispute<AccountId, Currency, BlockNumber, VoteMetadata, State> {
    locker: AccountId,
    locked_funds: Currency,
    dispute_raiser: AccountId,
    resolution_metadata: VoteMetadata,
    state: State,
    expiry: Option<BlockNumber>,
}

impl<
        AccountId: Clone + PartialEq,
        Currency: Clone,
        BlockNumber: Copy,
        VoteMetadata: Clone,
        State: Copy,
    > Dispute<AccountId, Currency, BlockNumber, VoteMetadata, State>
{
    pub fn locker(&self) -> AccountId {
        self.locker.clone()
    }
    pub fn locked_funds(&self) -> Currency {
        self.locked_funds.clone()
    }
    pub fn dispute_raiser(&self) -> AccountId {
        self.dispute_raiser.clone()
    }
    pub fn can_raise_dispute(&self, who: &AccountId) -> bool {
        &self.dispute_raiser() == who
    }
    pub fn resolution_metadata(&self) -> VoteMetadata {
        self.resolution_metadata.clone()
    }
    pub fn state(&self) -> State {
        self.state
    }
    pub fn expiry(&self) -> Option<BlockNumber> {
        self.expiry
    }
    // TODO: change this to trait impl for state transitions so we don't match in the runtime on the state to enforce valid transitions and instead depend on calls to the logic here
    pub fn set_state(&self, state: State) -> Self {
        Self {
            state,
            ..self.clone()
        }
    }
}

#[derive(new, PartialEq, Eq, Default, Clone, Encode, Decode, RuntimeDebug)]
pub struct ResolutionMetadata<OrgId, Threshold, BlockNumber> {
    org: OrgId,
    passage_threshold: Threshold,
    rejection_threshold: Option<Threshold>,
    duration: Option<BlockNumber>,
}

impl<OrgId: Copy, Threshold: Clone, BlockNumber: Copy>
    ResolutionMetadata<OrgId, Threshold, BlockNumber>
{
    pub fn org(&self) -> OrgId {
        self.org
    }
    pub fn passage_threshold(&self) -> Threshold {
        self.passage_threshold.clone()
    }
    pub fn rejection_threshold(&self) -> Option<Threshold> {
        self.rejection_threshold.clone()
    }
    pub fn duration(&self) -> Option<BlockNumber> {
        self.duration
    }
}

#[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, RuntimeDebug)]
pub enum DisputeState<VoteId> {
    DisputeNotRaised,
    /// Dispute raised and vote dispatched without outcome
    DisputeRaisedAndVoteDispatched(VoteId),
    /// Outcome and time last checked and outcome updated
    DisputeRaisedAndAccepted(VoteId),
    /// Outcome and time last checked and outcome updated
    DisputeRaisedAndRejected(VoteId),
}

impl<VoteId> Default for DisputeState<VoteId> {
    fn default() -> DisputeState<VoteId> {
        DisputeState::DisputeNotRaised
    }
}