Struct DefaultPolicyEngine 

pub struct DefaultPolicyEngine { /* private fields */ }

Default policy engine implementation.

Evaluates transactions against configured whitelist, blacklist, and limit rules. Uses TransactionHistory for tracking daily spending totals.

Rule Evaluation Order

1. Blacklist check (highest priority)
2. Whitelist check (if enabled)
3. Transaction limit check
4. Daily limit check
5. Allow (if all checks pass)

Thread Safety

This struct is Send + Sync and can be safely shared across threads. The underlying TransactionHistory handles concurrent access.

Implementations

impl DefaultPolicyEngine

pub fn new( config: PolicyConfig, history: Arc<TransactionHistory>, ) -> Result<Self, PolicyError>

Creates a new policy engine with the given configuration and history.

Arguments

• config - Policy configuration with whitelist, blacklist, and limits
• history - Transaction history for tracking daily totals

Returns

A new DefaultPolicyEngine instance.

Errors

Returns PolicyError::InvalidConfiguration if the configuration is invalid (e.g., an address appears in both whitelist and blacklist).

Example

use txgate_policy::engine::DefaultPolicyEngine;
use txgate_policy::config::PolicyConfig;
use txgate_policy::history::TransactionHistory;
use alloy_primitives::U256;
use std::sync::Arc;

let config = PolicyConfig::new()
    .with_whitelist(vec!["0xAAA".to_string()])
    .with_transaction_limit("ETH", U256::from(5_000_000_000_000_000_000u64));

let history = Arc::new(TransactionHistory::in_memory().unwrap());
let engine = DefaultPolicyEngine::new(config, history).unwrap();

Trait Implementations

impl Debug for DefaultPolicyEngine

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

Formats the value using the given formatter.

impl PolicyEngine for DefaultPolicyEngine

fn check(&self, tx: &ParsedTx) -> Result<PolicyResult, PolicyError>

Check if a transaction is allowed by policy rules.

fn record(&self, tx: &ParsedTx) -> Result<(), PolicyError>

Record a transaction that was signed (for limit tracking).