Struct frame_support::traits::EnsureOriginEqualOrHigherPrivilege

pub struct EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>(_);

EnsureOrigin implementation that checks that an origin has equal or higher privilege compared to the expected Origin.

It will take the shortcut of comparing the incoming origin with the expected Origin and if both are the same the origin is accepted.

Example

#[derive(Eq, PartialEq, Debug)]
pub enum Origin {
    Root,
    SomethingBelowRoot,
    NormalUser,
}

struct OriginPrivilegeCmp;

impl PrivilegeCmp<Origin> for OriginPrivilegeCmp {
    fn cmp_privilege(left: &Origin, right: &Origin) -> Option<Ordering> {
        match (left, right) {
            (Origin::Root, Origin::Root) => Some(Ordering::Equal),
            (Origin::Root, _) => Some(Ordering::Greater),
            (Origin::SomethingBelowRoot, Origin::SomethingBelowRoot) => Some(Ordering::Equal),
            (Origin::SomethingBelowRoot, Origin::Root) => Some(Ordering::Less),
            (Origin::SomethingBelowRoot, Origin::NormalUser) => Some(Ordering::Greater),
            (Origin::NormalUser, Origin::NormalUser) => Some(Ordering::Equal),
            (Origin::NormalUser, _) => Some(Ordering::Less),
        }
    }
}

parameter_types! {
    pub const ExpectedOrigin: Origin = Origin::SomethingBelowRoot;
}

type EnsureOrigin = EnsureOriginEqualOrHigherPrivilege<ExpectedOrigin, OriginPrivilegeCmp>;

// `Root` has an higher privilege as our expected origin.
assert!(EnsureOrigin::ensure_origin(Origin::Root).is_ok());
// `SomethingBelowRoot` is exactly the expected origin.
assert!(EnsureOrigin::ensure_origin(Origin::SomethingBelowRoot).is_ok());
// The `NormalUser` origin is not allowed.
assert!(EnsureOrigin::ensure_origin(Origin::NormalUser).is_err());

Trait Implementations

impl<OuterOrigin, Origin, PrivilegeCmp> EnsureOrigin<OuterOrigin> for EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>where
    Origin: Get<OuterOrigin>,
    OuterOrigin: Eq,
    PrivilegeCmp: PrivilegeCmp<OuterOrigin>,

type Success = ()

A return type.

fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin>

Perform the origin check.

fn ensure_origin(o: OuterOrigin) -> Result<Self::Success, BadOrigin>

Perform the origin check.