stake-reputation

;; title: stake-reputation
;; version:
;; summary:
;; description:

;;  Stakra - Enhanced Reputation Protocol Smart Contract
;; A comprehensive system for managing participant reputation with staking and governance

;; Error Definitions
;; Governance and access control errors (1xx range)
(define-constant ERR-ACCESS-DENIED (err u100))
(define-constant ERR-GOVERNANCE-DISABLED (err u101))
(define-constant ERR-PROPOSAL-EXISTS (err u102))

;; Validation and bounds errors (2xx range)
(define-constant ERR-VALIDATION-FAILED (err u200))
(define-constant ERR-BOUNDS-VIOLATION (err u201))
(define-constant ERR-THRESHOLD-UNMET (err u202))

;; Entity state errors (3xx range)
(define-constant ERR-ENTITY-NOT-FOUND (err u300))
(define-constant ERR-ENTITY-EXISTS (err u301))
(define-constant ERR-INVALID-STATE (err u302))

;; Economic constraints errors (4xx range)
(define-constant ERR-INSUFFICIENT-FUNDS (err u400))
(define-constant ERR-ECONOMIC-CONSTRAINT (err u401))

;; Protocol Constants
;; Reputation bounds
(define-constant REPUTATION-MINIMUM u0)
(define-constant REPUTATION-MAXIMUM u100)

;; Time-based constants
(define-constant EPOCH-LENGTH u144) ;; Approximately 1 day in blocks
(define-constant DECAY-INTERVAL u10000)
(define-constant DECAY-RATE u5)

;; Governance parameters
(define-constant PROPOSAL-THRESHOLD u75)
(define-constant VOTING-PERIOD u1008) ;; ~1 week in blocks

;; Economic parameters
(define-constant MINIMUM-COLLATERAL-REQUIREMENT u1000)
(define-constant COLLATERAL-MULTIPLIER u2)
(define-constant PENALTY-RATE u10)

;; Protocol State Variables
;; Administrative state
(define-data-var protocol-administrator principal tx-sender)
(define-data-var governance-enabled bool true)
(define-data-var protocol-parameters {
  min-reputation: uint,
  max-reputation: uint,
  collateral-requirement: uint,
  epoch-length: uint,
} {
  min-reputation: REPUTATION-MINIMUM,
  max-reputation: REPUTATION-MAXIMUM,
  collateral-requirement: MINIMUM-COLLATERAL-REQUIREMENT,
  epoch-length: EPOCH-LENGTH,
})

;; Protocol metrics
(define-data-var global-statistics {
  participant-count: uint,
  total-collateral: uint,
  total-evaluations: uint,
  current-epoch: uint,
} {
  participant-count: u0,
  total-collateral: u0,
  total-evaluations: u0,
  current-epoch: u0,
})

;; Data Maps
;; Participant core data
(define-map participant-registry
  principal
  {
    reputation-score: uint,
    last-active-epoch: uint,
    evaluation-count: uint,
    collateral-balance: uint,
    status: (string-ascii 20), ;; "ACTIVE", "SUSPENDED", "PROBATION"
  }
)

;; Evaluation and history tracking
(define-map evaluation-ledger
  {
    participant: principal,
    epoch: uint,
  }
  {
    base-score: uint,
    weighted-score: uint,
    evaluator: principal,
    timestamp: uint,
    metadata: (optional (string-utf8 100)),
  }
)

;; Evaluator authorization and reputation
(define-map evaluator-credentials
  principal
  {
    authorization-status: bool,
    evaluation-count: uint,
    accuracy-score: uint,
    last-evaluation: uint,
  }
)

;; Governance proposals and voting
(define-map governance-proposals
  uint ;; proposal-id
  {
    proposer: principal,
    description: (string-utf8 500),
    start-block: uint,
    end-block: uint,
    status: (string-ascii 10), ;; "ACTIVE", "PASSED", "FAILED", "EXECUTED"
    votes-for: uint,
    votes-against: uint,
    execution-payload: (optional (buff 1024)),
  }
)

(define-private (validate-participant-data (participant-data {
  reputation-score: uint,
  last-active-epoch: uint,
  evaluation-count: uint,
  collateral-balance: uint,
  status: (string-ascii 20),
}))
  (if (and
      (validate-reputation-bounds (get reputation-score participant-data))
      (>= (get collateral-balance participant-data)
        MINIMUM-COLLATERAL-REQUIREMENT
      )
      (or
        (is-eq (get status participant-data) "ACTIVE")
        (is-eq (get status participant-data) "SUSPENDED")
        (is-eq (get status participant-data) "PROBATION")
      )
    )
    (ok participant-data) ;; Return validated data instead of just true
    ERR-VALIDATION-FAILED
  )
)

(define-private (validate-metadata (metadata (optional (string-utf8 100))))
  (match metadata
    meta
    (if (< (len meta) u100)
      (ok metadata) ;; Return validated metadata
      ERR-VALIDATION-FAILED
    )
    (ok none) ;; None is always valid
  )
)

(define-private (calculate-weighted-reputation
    (current-score uint)
    (new-score uint)
    (evaluation-count uint)
    (evaluator-accuracy uint)
  )
  (let (
      (base-weight (/ (* current-score evaluation-count) (+ evaluation-count u1)))
      (new-weight (/ (* new-score evaluator-accuracy) (* u100 (+ evaluation-count u1))))
    )
    (+ base-weight new-weight)
  )
)

;; Private Functions
;; Validation functions
(define-private (validate-reputation-bounds (score uint))
  (let ((params (var-get protocol-parameters)))
    (and
      (>= score (get min-reputation params))
      (<= score (get max-reputation params))
    )
  )
)