Struct User 

pub struct User {

    pub pubkey: String,
    pub is_admin: i64,
    pub admin_password: Option<String>,
    pub is_solver: i64,
    pub is_banned: i64,
    pub category: i64,
    pub last_trade_index: i64,
    pub total_reviews: i64,
    pub total_rating: f64,
    pub last_rating: i64,
    pub max_rating: i64,
    pub min_rating: i64,
    pub created_at: i64,
    pub seeded_reviews: i64,
    pub seeded_rating_sum: f64,
    pub native_rating_sum: f64,
    pub native_created_at: Option<i64>,
    pub reputation_exported_to: Option<String>,
    pub reputation_exported_at: Option<i64>,
}

Database representation of a Mostro user.

This is the canonical row stored on the Mostro node. It tracks identity data (pubkey), administrative role flags, the last trade index used by the user and rating aggregates used to compute reputation.

Fields

pubkey: String

Master public key of the user, hex encoded.

is_admin: i64

1 when the user has admin privileges, 0 otherwise. Stored as i64 to match the underlying SQLite representation.

admin_password: Option<String>

Optional password used to authenticate privileged admin actions.

is_solver: i64

1 when the user is a dispute solver, 0 otherwise.

is_banned: i64

1 when the user is banned from the platform, 0 otherwise.

category: i64

Free-form category bucket. Reserved for future segmentation.

last_trade_index: i64

Last trade index used by this user. When a user creates a new order (or takes one) the incoming trade index must be strictly greater than this value, or the request is rejected.

total_reviews: i64

Total number of ratings the user has received.

total_rating: f64

Weighted rating average computed from all received ratings.

last_rating: i64

Most recent rating received, in the MIN_RATING..=MAX_RATING range.

max_rating: i64

Highest rating ever received.

min_rating: i64

Lowest rating ever received.

created_at: i64

Unix timestamp (seconds) the user’s age is shown from: when the record was created, moved back by an imported reputation’s earlier first-trade date.

seeded_reviews: i64

Ratings received through imported reputation, never natively. Internal only. See crate::reputation.

seeded_rating_sum: f64

Sum of rating × reviews over every imported reputation. Internal only.

native_rating_sum: f64

Sum of the raw ratings received natively, with no first-vote damping, so the native average is exact. Internal only.

A row that predates the column must be backfilled as total_rating * total_reviews before it takes a new rating: the default 0.0 would make the sum count only post-migration ratings. Rows from before any import have no seeded reviews, so that product is their whole native history, damped by the first vote.

native_created_at: Option<i64>

When the record was created, which an import never moves: what created_at goes back to when an import is reversed. Read it through User::native_created_at.

An Option on purpose: a database that predates the column reads it as None, and the accessor falls back to created_at; a plain i64 would default to 0 and place every such user in 1970.

reputation_exported_to: Option<String>

The identity this account’s reputation is bound to, as an issuer: the only identity an export may name without a rebind authorisation.

reputation_exported_at: Option<i64>

UTC day start of the last export. Day precision, so the record cannot time-correlate an export with an import elsewhere.

Implementations

impl User

pub fn new( pubkey: String, is_admin: i64, is_solver: i64, is_banned: i64, category: i64, trade_index: i64, ) -> Self

Create a new User with fresh rating aggregates.

trade_index becomes the user’s last_trade_index. The created_at timestamp is set to the current system time.

pub fn apply_reputation_import(&mut self, import: &ReputationImport)

Merge an imported reputation into this record (section 6 of the reputation portability plan).

Ratings received add up, the average is weighted by each origin’s review count, and the age is the earliest date, never a sum. min_rating, max_rating and last_rating are set from the imported average only where still 0. The import is also counted in seeded_reviews and seeded_rating_sum, so it is never exported as native reputation and can be reversed exactly; native_rating_sum and the native date are left alone. A record that predates the native_created_at column gets it pinned to its current created_at before that moves, so a reversal can restore it.

pub fn revert_reputation_import( &mut self, import: &ReputationImport, remaining_since: Option<i64>, )

Reverse an import merged by User::apply_reputation_import, as an operator does after an issuer key is compromised.

remaining_since is the earliest since among the imports that stay; the displayed date goes back to the earliest of it and the native date. Native ratings received in between are kept exactly, because the running average is linear in each contribution. The rating extrema are reset to 0 when no rating remains and are otherwise left as they are: they cannot be recomputed without a per-rating history.

pub fn native_stats(&self) -> (i64, f64)

The reputation this record earned on this instance alone: ratings received natively and their exact average (0.0 with none). This is what an export carries, so an imported reputation never travels on.

For a record that predates native_rating_sum, the migration backfills it from the displayed average, which the first vote damps; such a record exports the average its counterparties already see.

pub fn native_created_at(&self) -> i64

When the record was created, which no import ever moves.

Falls back to created_at for a record whose database predates the native_created_at column, never to 0.

pub fn update_rating(&mut self, rating: u8)

Record a new rating for the user and refresh the aggregates.

The first vote is weighted by 1/2 so that a single review cannot anchor a perfect or disastrous reputation. Subsequent votes update total_rating with an incremental running-average formula. min_rating and max_rating are tightened as new extremes arrive.

native_rating_sum accumulates the raw rating, undamped, so the average of the ratings received natively stays exact for a reputation export.

Example

use mostro_core::user::User;

let mut user = User::new("pubkey".into(), 0, 0, 0, 0, 0);
user.update_rating(5);
assert_eq!(user.total_reviews, 1);
assert_eq!(user.max_rating, 5);

Trait Implementations

impl Clone for User

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for User

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

Formats the value using the given formatter.

impl Default for User

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for User

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for User

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for User

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for User