reputation-derivatives

;; Reputation Derivatives - Clarity 4
;; Trade reputation score derivatives

(define-constant contract-owner tx-sender)
(define-constant err-not-found (err u12000))
(define-constant err-insufficient-funds (err u12001))
(define-constant err-invalid-price (err u12002))

(define-data-var position-nonce uint u0)

(define-map reputation-positions
    uint
    {
        trader: principal,
        builder: principal,
        predicted-score: uint,
        stake: uint,
        expiry-height: uint,
        settled: bool,
        payout: uint
    }
)

(define-map builder-reputation principal uint)

(define-read-only (get-position (position-id uint))
    (map-get? reputation-positions position-id)
)

(define-read-only (get-reputation (builder principal))
    (default-to u0 (map-get? builder-reputation builder))
)

(define-public (open-position
    (builder principal)
    (predicted-score uint)
    (stake uint)
    (duration-blocks uint)
)
    (let (
        (position-id (var-get position-nonce))
    )
        (try! (stx-transfer? stake tx-sender (as-contract tx-sender)))
        
        (map-set reputation-positions position-id {
            trader: tx-sender,
            builder: builder,
            predicted-score: predicted-score,
            stake: stake,
            expiry-height: (+ stacks-block-height duration-blocks),
            settled: false,
            payout: u0
        })
        
        (var-set position-nonce (+ position-id u1))
        (ok position-id)
    )
)

(define-public (settle-position (position-id uint))
    (let (
        (position (unwrap! (get-position position-id) err-not-found))
        (actual-score (get-reputation (get builder position)))
        (predicted (get predicted-score position))
        (difference (if (> actual-score predicted)
            (- actual-score predicted)
            (- predicted actual-score)))
        ;; Simple payout: closer prediction = higher payout
        (payout (if (< difference u10)
            (* (get stake position) u2)
            (if (< difference u50)
                (get stake position)
                u0
            )
        ))
    )
        (asserts! (>= stacks-block-height (get expiry-height position)) err-not-found)
        (asserts! (not (get settled position)) err-not-found)
        
        (map-set reputation-positions position-id 
            (merge position {settled: true, payout: payout})
        )
        
        (if (> payout u0)
            (try! (as-contract (stx-transfer? payout tx-sender (get trader position))))
            true
        )
        (ok payout)
    )
)

(define-public (update-reputation (builder principal) (score uint))
    (begin
        (asserts! (is-eq tx-sender contract-owner) err-not-found)
        (ok (map-set builder-reputation builder score))
    )
)