Struct ElectedModerators 

pub struct ElectedModerators {
    pub join_window: u32,
    pub vote_window: u32,
    pub challenge_cool_down: Option<u32>,
    pub election_delay: Option<u32>,
    pub max_added_moderators: u16,
    pub moderated_document_types: BTreeMap<DocumentName, BTreeSet<ModerationAbility>>,
    pub interim: InterimModerators,
    pub owner_protected: bool,
}

The declaration that a contract’s moderators are an elected team. Every field is fixed at the contract’s creation.

Fields

join_window: u32

How long, in seconds, applicants may join an election once the first one applied. At most SystemLimits::max_contract_moderation_election_window_seconds (four weeks), and on mainnet at least SystemLimits::min_mainnet_contract_moderation_election_window_seconds (one day); any other network takes 0. DEFAULT_ELECTION_WINDOW_SECONDS when the declaration leaves it out.

vote_window: u32

How long, in seconds, masternodes vote once the join window closed. The same bounds and default.

challenge_cool_down: Option<u32>

Whether the seat can be contested again once a team is seated, and if so how long, in seconds, a seated team is safe from a challenge after a seat change.

Some when the seat is contestable (seatContestable: true on the wire, with the cool-down as challengeCoolDown), within SystemLimits::min_contract_moderation_challenge_cool_down_seconds to SystemLimits::max_contract_moderation_challenge_cool_down_seconds (two weeks to three years). None when it is not (seatContestable: false, no challengeCoolDown): the first team seated keeps the seat for good, whatever becomes of its leader. One field rather than a flag beside a cool-down, so the two can not disagree.

Nothing reads it yet: challenges come after protocol version 14, and until they do a seat is never contested again, whatever this says. The key exists now because the declaration is frozen at the contract’s creation.

election_delay: Option<u32>

How long, in seconds after the contract’s creation, before the first charter may be filed against the contract: the notice the contract gives before its first election can be called. Unbounded, and None when the declaration leaves it out, in which case the election may be called at once. A reference declaring contractRequirements: { "moderation": "electionOpen" } is what reads it.

max_added_moderators: u16

How many members the leader of a seated team may add after the election, each one an identity that asked to join the team’s proposal: the additions a seated charter holds at a time, the leader taking one back by deleting it. 0 when the declaration leaves it out, a team then being exactly what was elected; at most SystemLimits::max_contract_moderation_added_moderators. The moderation charters contract’s addedModerator documents are what it counts.

moderated_document_types: BTreeMap<DocumentName, BTreeSet<ModerationAbility>>

The document types the team moderates, each with the abilities the seated team holds on it: non-empty, each type a document type of the contract, each ability set non-empty and backed by the contract (Ban, Suspend and Warn by the list the contract keeps, DeleteDocuments by the type setting moderatorAbilities.delete, ChangeDocumentFields by the type listing moderatorAbilities.changeFields). The lists themselves stay contract-wide: an ability on a type is what a team may do over the documents of that type. The set also bounds the interim block. A charter does not price the moderators part of an action: the type’s actionFees.moderators amount is the most a team may charge, and a charter charges a share of it.

interim: InterimModerators

Who moderates until the first team is seated.

owner_protected: bool

Whether the contract owner is protected from the team, as the owner and the moderators of the merged kinds are: it can then be neither banned nor suspended, and its documents can not be deleted. Not protected by default. During the interim the owner is protected whenever it moderates, flag or not.

Implementations

impl ElectedModerators

pub fn seat_contestable(&self) -> bool

Whether the seat can be contested again once a team is seated: the declaration’s seatContestable. A challenge will be allowed only on a contract that says so.

pub fn election_is_open( &self, contract_created_at: Option<TimestampMillis>, block_time_ms: TimestampMillis, ) -> bool

Whether the first election may be called at block_time_ms on a contract created at contract_created_at: the declaration has no election delay, or the delay has passed since the creation. An elected declaration is made at the contract’s creation and never changes, so the creation is the declaration’s own time. A contract without a recorded creation time and with a delay is of unknown age, and its election is not open.

pub fn moderates_document_type(&self, document_type_name: &str) -> bool

Whether the team moderates the document type

pub fn allows( &self, document_type_name: &str, ability: ModerationAbility, ) -> bool

Whether the seated team holds the ability on the document type

pub fn allows_on_any_type(&self, ability: ModerationAbility) -> bool

Whether the seated team holds the ability on some moderated document type. The lists are contract-wide, so this is what lets the team ban, suspend or warn (and lift each): an ability on a type is what the team may do over the documents of that type, and an identity is barred from the whole contract.

pub fn interim_blocks_document_type(&self, document_type_name: &str) -> bool

Whether the interim refuses every document transition of the document type: the interim names nobody and the type is moderated. This is the declaration’s side only: the block ends once a charter is seated on the contract, which only state says, so the document gate reads whether one is before it refuses.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for ElectedModerators

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<'__de, __Context> BorrowDecodeUntrusted<'__de, __Context> for ElectedModerators

fn borrow_decode_untrusted<__D: BorrowUntrustedDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Borrow-decode with explicit untrusted field dispatch and resource handling.

impl Clone for ElectedModerators

fn clone(&self) -> ElectedModerators

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ElectedModerators

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for ElectedModerators

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<__Context> DecodeUntrusted<__Context> for ElectedModerators

fn decode_untrusted<__D: UntrustedDecoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Decode with explicit untrusted field dispatch and resource handling.

impl Display for ElectedModerators

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Encode for ElectedModerators

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl Eq for ElectedModerators

impl JsonSafeFields for ElectedModerators

Available on crate feature json-conversion only.

impl PartialEq for ElectedModerators

fn eq(&self, other: &ElectedModerators) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ElectedModerators