casper-contract-sdk 0.1.2

Casper contract sdk package
Documentation 
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

//! This module provides a trait for pausable contracts.
//!
//! The `Pausable` trait allows contracts to be paused and unpaused, which can be useful
//! in scenarios where the contract needs to be temporarily disabled for maintenance or
//! security reasons. The trait provides methods to check the current pause state, as well
//! as to pause and unpause the contract.
//!
//! The `Pausable` trait is designed to be used with the `casper` macro, which generates
//! the necessary boilerplate code for the contract.
//!
//! For security reasons you may want to combine [`AccessControl`] or [`Ownable`] with
//! this trait to ensure that only selected entities can manage the pause state.
use crate::{self as casper_contract_sdk, casper, casper::Entity, macros::casper};

#[casper]
pub struct PausedState {
    paused: bool,
}

#[casper(path = crate)]
pub enum PausableError {
    EnforcedPause,
    ExpectedPause,
}

/// The `Paused` event is emitted when the contract is paused.
#[casper(message, path = crate)]
pub struct Paused {
    entity: Entity,
}

/// The `Unpaused` event is emitted when the contract is unpaused.
#[casper(message, path = crate)]
pub struct Unpaused {
    entity: Entity,
}

/// Pausable is a trait that provides a simple way to pause and unpause a contract.
#[casper(path = crate, export = true)]
pub trait Pausable {
    /// The state of the contract, which contains the paused state.
    #[casper(private)]
    fn state(&self) -> &PausedState;
    /// The mutable state of the contract, which allows modifying the paused state.
    #[casper(private)]
    fn state_mut(&mut self) -> &mut PausedState;

    /// Checks if the contract is paused.
    #[casper(private)]
    fn paused(&self) -> bool {
        self.state().paused
    }

    #[casper(private)]
    fn pause(&mut self) -> Result<(), PausableError> {
        self.enforce_unpaused()?;
        self.state_mut().paused = true;
        casper::emit(Paused {
            entity: casper::get_caller(),
        })
        .expect("Emit");
        Ok(())
    }

    #[casper(private)]
    fn unpause(&mut self) -> Result<(), PausableError> {
        self.enforce_paused()?;
        self.state_mut().paused = false;
        casper::emit(Unpaused {
            entity: casper::get_caller(),
        })
        .expect("Emit");
        Ok(())
    }

    #[casper(private)]
    fn enforce_paused(&self) -> Result<(), PausableError> {
        if self.paused() {
            Ok(())
        } else {
            Err(PausableError::ExpectedPause)
        }
    }

    #[casper(private)]
    fn enforce_unpaused(&self) -> Result<(), PausableError> {
        if !self.paused() {
            Ok(())
        } else {
            Err(PausableError::EnforcedPause)
        }
    }
}