Enum mpl_token_auth_rules::state::Rule

pub enum Rule {
    All {
        rules: Vec<Rule>,
    },
    Any {
        rules: Vec<Rule>,
    },
    Not {
        rule: Box<Rule>,
    },
    AdditionalSigner {
        account: Pubkey,
    },
    PubkeyMatch {
        pubkey: Pubkey,
        field: String,
    },
    PubkeyListMatch {
        pubkeys: Vec<Pubkey>,
        field: String,
    },
    PubkeyTreeMatch {
        root: [u8; 32],
        field: String,
    },
    PDAMatch {
        program: Option<Pubkey>,
        pda_field: String,
        seeds_field: String,
    },
    ProgramOwned {
        program: Pubkey,
        field: String,
    },
    ProgramOwnedList {
        programs: Vec<Pubkey>,
        field: String,
    },
    ProgramOwnedTree {
        _root: [u8; 32],
        _program_field: String,
        _merkle_proof_field: String,
    },
    Amount {
        amount: u64,
        operator: CompareOp,
        field: String,
    },
    Frequency {
        authority: Pubkey,
    },
    Pass,
}

The struct containing every type of Rule and its associated data.

Variants

All

Fields

rules: Vec<Rule>

The vector of Rules contained under All.

Group AND, where every rule contained must pass.

Any

Fields

rules: Vec<Rule>

The vector of Rules contained under Any.

Group OR, where at least one rule contained must pass.

Not

Fields

rule: Box<Rule>

The Rule contained under Not.

Negation, where the contained rule must fail.

AdditionalSigner

Fields

account: Pubkey

The public key that must have also signed the transaction.

An additional signer must be present.

PubkeyMatch

Fields

pubkey: Pubkey

The public key to be compared against.

field: String

The field in the Payload to be compared.

Direct comparison between Pubkeys.

PubkeyListMatch

Fields

pubkeys: Vec<Pubkey>

The list of public keys to be compared against.

field: String

The field in the Payload to be compared.

The comparing Pubkey must be in the list of Pubkeys.

PubkeyTreeMatch

Fields

root: [u8; 32]

The root of the Merkle tree.

field: String

The field in the Payload to be compared.

The pubkey must be a member of the Merkle tree.

PDAMatch

Fields

program: Option<Pubkey>

The program used for the PDA derivation. If None then the account owner is used.

pda_field: String

The field in the Payload to be compared when looking for the PDA.

seeds_field: String

The field in the Payload to be compared when looking for the seeds.

A resulting PDA derivation of seeds must prove the account is a PDA.

ProgramOwned

Fields

program: Pubkey

The program that must own the Pubkey.

field: String

The field in the Payload to be compared.

The Pubkey must be owned by a given program.

ProgramOwnedList

Fields

programs: Vec<Pubkey>

The program that must own the Pubkey.

field: String

The field in the Payload to be compared.

The Pubkey must be owned by a program in the list of Pubkeys.

ProgramOwnedTree

Fields

_root: [u8; 32]

The root of the Merkle tree.

_program_field: String

The field in the Payload to be compared when looking for the program.

_merkle_proof_field: String

The field in the Payload to be compared when looking for the Merkle Proof.

The Pubkey must be owned a member of the Merkle tree.

Amount

Fields

amount: u64

The amount to be compared against.

operator: CompareOp

The operator to be used in the comparison.

field: String

The field the amount is stored in.

Comparison against the amount of tokens being transferred.

Frequency

Fields

authority: Pubkey

The authority of the frequency account.

Comparison based on time between operations.

Pass

An operation that always succeeds.

Implementations

impl Rule

pub fn validate(
    &self,
    accounts: &HashMap<Pubkey, &AccountInfo<'_>>,
    payload: &Payload,
    update_rule_state: bool,
    rule_set_state_pda: &Option<&AccountInfo<'_>>,
    rule_authority: &Option<&AccountInfo<'_>>
) -> ProgramResult

The top level validation function which parses an entire rule tree.

pub fn low_level_validate(
    &self,
    accounts: &HashMap<Pubkey, &AccountInfo<'_>>,
    payload: &Payload,
    _update_rule_state: bool,
    _rule_set_state_pda: &Option<&AccountInfo<'_>>,
    rule_authority: &Option<&AccountInfo<'_>>
) -> (bool, ProgramError)

Lower level validation function which iterates through a rule tree and applies boolean logic to rule results.

pub fn to_error(&self) -> ProgramError

Convert the rule to a corresponding error resulting from the rule failure.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Rule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Rule> for Rule

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Rule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Rule

impl StructuralEq for Rule

impl StructuralPartialEq for Rule