Struct ReputationEngine 

pub struct ReputationEngine {
    pub user_pubkey: String,
    pub layer_scores: HashMap<CaptureLayer, ReputationDimension>,
    pub account_created: u64,
    pub total_attestations: u64,
    /* private fields */
}

Main reputation engine

Fields

user_pubkey: String

User public key (Solana address)

layer_scores: HashMap<CaptureLayer, ReputationDimension>

Score for each capture layer

account_created: u64

Account creation timestamp

total_attestations: u64

Total attestations processed

Implementations

impl ReputationEngine

pub fn new(user_pubkey: String) -> Self

Create new reputation engine for a user

pub fn process_attestation<A: Attestation>(&mut self, attestation: &A)

Process an attestation from any capture layer

pub fn calculate_trust_score(&mut self) -> TrustScore

Calculate composite trust score

pub fn verify_threshold( &mut self, threshold_name: &str, commitment: &str, ) -> Option<bool>

Verify a threshold proof (external parties can check without seeing score)

pub fn can_coordinate_swarm(&mut self) -> bool

Check if user can coordinate sub-agents (Layer 22 gate)

pub fn qualifies_for_collateral(&mut self) -> bool

Check if user qualifies for reputation collateral (Layer 21)

pub fn collateral_discount_bps(&mut self) -> u16

Get collateral discount rate in basis points

pub fn max_sub_agents(&mut self) -> u8

Get maximum sub-agents this user can hire

impl ReputationEngine

pub fn to_api_response(&mut self) -> ReputationResponse

Generate API response

impl ReputationEngine

Extension trait for ReputationEngine to load from Supabase

pub async fn load_from_supabase( &mut self, client: &SupabaseClient, ) -> Result<usize, String>

Load attestations from Supabase and process them

pub async fn from_supabase( user_pubkey: String, client: &SupabaseClient, ) -> Result<Self, String>

Create engine and load from Supabase in one step

Trait Implementations

impl Debug for ReputationEngine

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

Formats the value using the given formatter.