Enum 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],
        pubkey_field: String,
        proof_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],
        pubkey_field: String,
        proof_field: String,
    },
    Amount {
        amount: u64,
        operator: CompareOp,
        field: String,
    },
    Frequency {
        authority: Pubkey,
    },
    IsWallet {
        field: String,
    },
    Pass,
    ProgramOwnedSet {
        programs: HashSet<Pubkey>,
        field: String,
    },
    Namespace,
}

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

Variants

All

Group AND, where every rule contained must pass.

Fields

rules: Vec<Rule>

The vector of Rules contained under All.

Any

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

Fields

rules: Vec<Rule>

The vector of Rules contained under Any.

Not

Negation, where the contained rule must fail.

Fields

rule: Box<Rule>

The Rule contained under Not.

AdditionalSigner

An additional signer must be present. When the Validate instruction is called, this rule does not require any Payload values, but the additional signer account must be provided to Validate via the additional_rule_accounts argument so that whether it is a signer can be retrieved from its AccountInfo struct.

Fields

account: Pubkey

The public key that must have also signed the transaction.

PubkeyMatch

Direct comparison between Pubkeys. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Pubkey. The field value in the rule is used to locate the Pubkey in the payload to compare to the Pubkey in the rule.

Fields

pubkey: Pubkey

The public key to be compared against.

field: String

The field in the Payload to be compared.

PubkeyListMatch

The comparing Pubkey must be in the list of Pubkeys. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Pubkey. The field value in the Rule is used to locate the Pubkey in the payload to compare to the Pubkey list in the rule.

Fields

pubkeys: Vec<Pubkey>

The list of public keys to be compared against.

field: String

The field in the Payload to be compared.

PubkeyTreeMatch

The comparing Pubkey must be a member of the Merkle tree in the rule. When the Validate instruction is called, this rule requires PayloadType values of PayloadType::Pubkey and PayloadType::MerkleProof. The field values in the Rule are used to locate them in the Payload. The Pubkey and the proof are used to calculate a Merkle root which is compared against the root stored in the rule.

Fields

root: [u8; 32]

The root of the Merkle tree.

pubkey_field: String

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

proof_field: String

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

PDAMatch

A resulting PDA derivation of seeds must prove the account is a PDA. When the Validate instruction is called, this rule requires PayloadType values of PayloadType::Seeds. The field values in the Rule are used to locate them in the Payload. The seeds in the Payload and the program ID stored in the Rule are used to derive the PDA from the Payload.

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.

ProgramOwned

The Pubkey must be owned by a given program. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Pubkey. The field value in the rule is used to locate the Pubkey in the payload for which the owner must be the program in the rule. Note this same Pubkey account must also be provided to Validate via the additional_rule_accounts argument. This is so that the Pubkey’s owner can be found from its AccountInfo struct.

Fields

program: Pubkey

The program that must own the Pubkey.

field: String

The field in the Payload to be compared.

ProgramOwnedList

The Pubkey must be owned by a program in the list of Pubkeys. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Pubkey. The field value in the rule is used to locate the Pubkey in the payload for which the owner must be a program in the list in the rule. Note this same Pubkey account must also be provided to Validate via the additional_rule_accounts argument. This is so that the Pubkey’s owner can be found from its AccountInfo struct.

Fields

programs: Vec<Pubkey>

The program that must own the Pubkey.

field: String

The field in the Payload to be compared.

ProgramOwnedTree

The Pubkey must be owned by a member of the Merkle tree in the rule. When the Validate instruction is called, this rule requires PayloadType values of PayloadType::Pubkey and PayloadType::MerkleProof. The field values in the Rule are used to locate them in the Payload. Note this same Pubkey account must also be provided to Validate via the additional_rule_accounts argument. This is so that the Pubkey’s owner can be found from its AccountInfo struct. The owner and the proof are then used to calculate a Merkle root, which is compared against the root stored in the rule.

Fields

root: [u8; 32]

The root of the Merkle tree.

pubkey_field: String

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

proof_field: String

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

Amount

Comparison against the amount of tokens being transferred. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Amount. The field value in the Rule is used to locate the numerical amount in the payload to compare to the amount stored in the rule, using the comparison operator stored in the rule.

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.

Frequency

Comparison based on time between operations. Currently not implemented. This rule is planned check to ensure a certain amount of time has passed. This rule will make use of the rule_set_state_pda optional account passed into Validate, and will require the optional rule_authority account to sign.

Fields

authority: Pubkey

The authority of the frequency account.

IsWallet

The true test if a pubkey can be signed from a client and therefore is a true wallet account. The details of this rule are as follows: a wallet is defined as being both owned by the System Program and the address is on-curve. The field value in the rule is used to locate the Pubkey in the payload that must be on-curve and for which the owner must be the System Program. Note this same Pubkey account must also be provided to Validate via the additional_rule_accounts argument. This is so that the Pubkey’s owner can be found from its AccountInfo struct.

Fields

field: String

The field in the Payload to be checked.

Pass

An operation that always succeeds.

ProgramOwnedSet

The Pubkey must be owned by a program in the set of Pubkeys. When the Validate instruction is called, this rule requires a PayloadType value of PayloadType::Pubkey. The field value in the rule is used to locate the Pubkey in the payload for which the owner must be a program in the set in the rule. Note this same Pubkey account must also be provided to Validate via the additional_rule_accounts argument. This is so that the Pubkey’s owner can be found from its AccountInfo struct.

Fields

programs: HashSet<Pubkey>

The program that must own the Pubkey.

field: String

The field in the Payload to be compared.

Namespace

A rule that tells the operation finder to use the default namespace rule.

Implementations

impl Rule

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<'_>>, ) -> RuleResult

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<'a> Assertable<'a> for Rule

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.

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate 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 for Rule

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

Tests for self and other values to be equal, and is used by ==.

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

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 StructuralPartialEq for Rule