Welsh Street Rewards System

;; scale UP before dividing to preserve fractional precision
(index-increment (if (> total-lp u0)
  (/ (* amount PRECISION) total-lp)
  u0))

;; scale DOWN after multiplication to get actual claimable amount
(earned-a (/ (* balance (- current-global-a user-index-a)) PRECISION))

;; index increment calculation
(/ (* 1000000 1000000000000000000) 1000000)
= 1000000000000000000
 
;; represents exactly 1.0 µWELSH per LP token with zero precision loss

;; street rewards data structure
 
;; 18-decimal fixed scaling factor
(define-constant PRECISION u1000000000000000000)
 
;; global cumulative indexes (never decrease, only increase)
(define-data-var global-index-a uint u0)
(define-data-var global-index-b uint u0)
 
;; cleanup function call tracking 
(define-data-var last-cleanup-block uint u0)
 
;; total distributes tracked for onchain accounting
(define-data-var total-distributed-a uint u0)
(define-data-var total-distributed-b uint u0)
 
;; total claimed tracked for onchain accounting
(define-data-var total-claimed-a uint u0)
(define-data-var total-claimed-b uint u0)
 
(define-map users
  { account: principal }
  {
    ;; user's LP token-balance
    balance: uint,
 
    ;; block "snapshot" when user joined/updated
    block: uint,      
    
    ;; accumulated claimed tokens (zero debt initialization)
    debt-a: uint,        
    debt-b: uint,        
    
    ;; user's snapshot of global-index at join or change liquidity
    index-a: uint,       
    index-b: uint        
  }
)

(define-public (claim-rewards)
  (let (
    ;; fetch user's current balance. Guarantees sync with current state
    (balance (unwrap-panic (contract-call? .credit-token get-balance contract-caller)))
 
    ;; load or initialize user's reward snapshot
    (info (default-to {
      balance: u0,
      block: u0,
      debt-a: u0,
      debt-b: u0,
      index-a: u0,
      index-b: u0}
      (map-get? users { account: contract-caller })))
 
    ;; read latest global reward indexes
    (current-global-a (var-get global-index-a))
    (current-global-b (var-get global-index-b))
 
    ;; previously claimed amounts (debt) for each token
    (debt-a (get debt-a info))
    (debt-b (get debt-b info))
    
    ;; user's join-time index snapshots
    (user-index-a (get index-a info))
    (user-index-b (get index-b info))
    
    ;; total earned based on balance and index delta
    (earned-a (/ (* balance (- current-global-a user-index-a)) PRECISION))
    (earned-b (/ (* balance (- current-global-b user-index-b)) PRECISION))
    
    ;; claimable rewards = earned minus prior debt
    (unclaimed-a (if (> earned-a debt-a) (- earned-a debt-a) u0))
    (unclaimed-b (if (> earned-b debt-b) (- earned-b debt-b) u0))
  )
    ;; transfer claimable rewards and update reward tracking
    (begin
      (if (> unclaimed-a u0)
        (try! (transformer .welshcorgicoin unclaimed-a contract-caller))
        true
      )
      (if (> unclaimed-b u0)
        (try! (transformer .street-token unclaimed-b contract-caller))
        true
      )
      ;; bump global claimed totals
      (var-set total-claimed-a (+ (var-get total-claimed-a) unclaimed-a))
      (var-set total-claimed-b (+ (var-get total-claimed-b) unclaimed-b))
      
      ;; refresh user's snapshot with new debt and balance
      (map-set users { account: contract-caller } {
        balance: balance,
        block: (get block info),
        debt-a: (+ debt-a unclaimed-a),
        debt-b: (+ debt-b unclaimed-b),
        index-a: user-index-a,
        index-b: user-index-b
        })
      
      (ok {
        amount-a: unclaimed-a,
        amount-b: unclaimed-b,
        })  
    )
  )
)

(define-public (donate-rewards (amount-a uint) (amount-b uint))
    (begin
      
      ;; optional WELSH donation
      (if (> amount-a u0)
      (begin
 
        ;; transfer WELSH from caller into the street-rewards contract
        (try! (contract-call? .welshcorgicoin transfer amount-a contract-caller .street-rewards none))
 
        ;; as street-rewards, inject donated WELSH into the index via update-rewards-a
        (try! (as-contract? ()
          (try! (update-rewards-a amount-a))))
      )
        true
      )
      
      ;; optional STREET donation
      (if (> amount-b u0)
      (begin
 
        ;; transfer STREET from caller into the street-rewards contract
        (try! (contract-call? .street-token transfer amount-b contract-caller .street-rewards none))
 
        ;; as street-rewards, inject donated STREET into the index via update-rewards-b
        (try! (as-contract? ()
          (try! (update-rewards-b amount-b))))
      )
        true
      )
    (ok {
      amount-a: amount-a,
      amount-b: amount-b
    })
  )
)

(define-public (decrease-rewards (user principal) (amount uint))
  (let (
    ;; user's current CREDIT balance (AFTER amount was removed)
    (balance (unwrap-panic (contract-call? .credit-token get-balance user)))
 
    ;; snapshot timing stored into the user record
    (block stacks-block-height)
    
    ;; current global reward indexes (cumulative rewards per LP token)
    (global-a (var-get global-index-a))
    (global-b (var-get global-index-b))
    
    ;; user's stored state (must exist - unwrap-panic will fail if not)
    (info (unwrap-panic (map-get? users { account: user })))
    
    ;; total CREDIT supply across all holders
    (total-lp (unwrap-panic (contract-call? .credit-token get-total-supply)))
    
    ;; user's CREDIT balance before the reduction
    (old-balance (+ balance amount))
 
    ;; all LP held by OTHER users (excludes this user's full old-balance)
    ;; note: total-lp is already post-decrease (reflects current on-chain supply)
    ;; so (- total-lp old-balance) correctly gives everyone else's LP
    (other-lp (- total-lp old-balance))
  )
    (begin
      ;; only controller or market can shrink positions
      (asserts! (or (is-eq contract-caller .credit-controller)
                    (is-eq contract-caller .street-market)) ERR_NOT_AUTHORIZED)
      
      (asserts! (> amount u0) ERR_ZERO_AMOUNT)
      (let (
 
        ;; debt offset used to prevent double-counting existing rewards
        ;; (not the amount claimed - it's a calculated offset in the formula)
        (debt-a (get debt-a info))
        (debt-b (get debt-b info))
        
        ;; user's stored index snapshots (last time their state was updated)
        (index-a (get index-a info))
        (index-b (get index-b info))
        
        ;; compute earned: balance × (global-index - user-index) / PRECISION
        ;; represents rewards accrued since user's last index snapshot
        (earned-a (/ (* old-balance (- global-a index-a)) PRECISION))
        (earned-b (/ (* old-balance (- global-b index-b)) PRECISION))
        
        ;; unclaimed rewards = earned minus prior debt
        (unclaimed-a (if (> earned-a debt-a) (- earned-a debt-a) u0))
        (unclaimed-b (if (> earned-b debt-b) (- earned-b debt-b) u0))
        
        ;; portion of unclaimed rewards that must be forfeited
        ;; proportional to LP removed relative to old balance
        (forfeit-a (/ (* unclaimed-a amount) old-balance))
        (forfeit-b (/ (* unclaimed-b amount) old-balance))
        
        ;; convert forfeited rewards into index increments for other LPs
        ;; forfeited rewards are immediately redistributed to remaining LP holders
        ;; global index increases so remaining holders earn the forfeited portion
        (redistributed-a (if (> other-lp u0)
                      (/ (* forfeit-a PRECISION) other-lp)
                      u0))
        (redistributed-b (if (> other-lp u0)
                      (/ (* forfeit-b PRECISION) other-lp)
                      u0))
      )
        (begin
          ;; bump global indexes by redistributed amounts
          (if (> forfeit-a u0)
            (begin
              (var-set global-index-a (+ global-a redistributed-a)))
            true)
          (if (> forfeit-b u0)
            (begin
              (var-set global-index-b (+ global-b redistributed-b)))
            true)
          
          (let (
            ;; global indexes after applying forfeits
            (new-global-a (var-get global-index-a))
            (new-global-b (var-get global-index-b))
            
            ;; remainder of unclaimed rewards that stay with the user
            (preserve-a (- unclaimed-a forfeit-a))
            (preserve-b (- unclaimed-b forfeit-b))
            
            ;; derive new index that preserves remaining rewards on new balance
            ;; adjusts user index backward so reward formula yields correct preserved amount
            (preserve-idx-a (if (and (> balance u0) (> preserve-a u0))
                        (- new-global-a (/ (* preserve-a PRECISION) balance))
                        new-global-a))
            (preserve-idx-b (if (and (> balance u0) (> preserve-b u0))
                        (- new-global-b (/ (* preserve-b PRECISION) balance))
                        new-global-b))
          )
            ;; BRANCH — partial removal (balance > 0):
            ;; overwrite user record with recalculated preserve-idx and zeroed debt
            (if (> balance u0)
              (map-set users
                { account: user }
                { balance: balance,
                  block: block,
                  debt-a: u0,
                  debt-b: u0, 
                  index-a: preserve-idx-a,
                  index-b: preserve-idx-b
                })
                
              ;; BRANCH — total removal (balance = 0):
              ;; delete user record — ALL unclaimed rewards
              ;; were already forfeited and redistributed above
              (map-delete users { account: user }))
            )
          (ok true)
        )
      )
    )
  )
)

(define-public (increase-rewards (user principal) (amount uint))
  (let (
    
    ;; user's new CREDIT balance after increase
    (balance (unwrap-panic (contract-call? .credit-token get-balance user)))
 
    ;; snapshot timing stored into the user record
    (block stacks-block-height)
    
    ;; snapshot current global reward indexes for both tokens
    (global-a (var-get global-index-a))
    (global-b (var-get global-index-b))
    
    ;; existing user info if present
    ;; no error check because user state may not exist (receive transfer)
    (info (map-get? users { account: user }))
    
    ;; previous balance before increase
    (old-balance (- balance amount))
  )
    (begin
      ;; only credit-controller (transfers) or 
      ;; street-market (provide-liquidity) can increase positions
      (asserts! (or (is-eq contract-caller .credit-controller)
                    (is-eq contract-caller .street-market)) ERR_NOT_AUTHORIZED)
      (asserts! (> amount u0) ERR_ZERO_AMOUNT)
      
      ;; if user already has a rewards snapshot, preserve existing unclaimed
      ;; using index adjustment (preserve-idx) — same pattern as decrease-rewards
      (if (is-some info)
        (let (
          
          ;; unwrap stored user record
          (data (unwrap-panic info))
          
          ;; debt offset used to prevent double-counting existing rewards
          ;; (not the amount claimed - it's a calculated offset in the formula)
          (debt-a (get debt-a data))
          (debt-b (get debt-b data))
          
          ;; user's stored index snapshots (last time their state was updated)
          (index-a (get index-a data))
          (index-b (get index-b data))
          
          ;; compute earned: old-balance × (global-index - user-index) / PRECISION
          ;; represents rewards accrued on old balance since user's last index snapshot
          (earned-a (/ (* old-balance (- global-a index-a)) PRECISION))
          (earned-b (/ (* old-balance (- global-b index-b)) PRECISION))
          
          ;; Compare what user should have earned (earned-*) to what they already took (debt-*).
          ;; If earned > debt → unclaimed = difference.
          ;; If earned ≤ debt → unclaimed = 0 (no negative unclaimed).
          (unclaimed-a (if (> earned-a debt-a) (- earned-a debt-a) u0))
          (unclaimed-b (if (> earned-b debt-b) (- earned-b debt-b) u0))
          
          ;; BRANCH — Existing user (index adjustment):
          ;; preserve unclaimed rewards by adjusting user index backward, zeroing debt
          ;; adjusted index ensures reward formula yields same unclaimed amount on new balance
          (preserve-idx-a (if (> unclaimed-a u0)
                            (- global-a (/ (* unclaimed-a PRECISION) balance))
                            global-a))
          (preserve-idx-b (if (> unclaimed-b u0)
                            (- global-b (/ (* unclaimed-b PRECISION) balance))
                            global-b))
        )
          ;; reset debt to zero and set user index to calculated preserve-idx
          (map-set users { account: user } {
            balance: balance,
            block: block,
            debt-a: u0,
            debt-b: u0,
            index-a: preserve-idx-a,
            index-b: preserve-idx-b
          })
        )
 
        ;; BRANCH — New user (info is none):
        ;; initialize snapshot at current global indexes with zero debt
        ;; no prior rewards to preserve
        (map-set users { account: user } {
          balance: balance,
          block: block,
          debt-a: u0,
          debt-b: u0,
          index-a: global-a,
          index-b: global-b
        })
      )
      (ok true)
    )
  )
)

;; add WELSH rewards into the index for token-a
(define-public (update-rewards-a (amount uint))
  (let (
      
      ;; total current CREDIT supply used to split rewards pro‑rata
      (total-lp (unwrap-panic (contract-call? .credit-token get-total-supply)))
      
      ;; current global index for token-a before adding this amount
      (current-index (var-get global-index-a))
      
      ;; index increment = amount / total CREDIT (scaled by PRECISION)
      (index-increment (if (> total-lp u0)
        (/ (* amount PRECISION) total-lp)
        u0))
      
      ;; updated global index for token-a after this reward injection
      (new-index (+ current-index index-increment))
      
      ;; updated on-chain accounting total of all WELSH ever distributed
      (new-rewards (+ (var-get total-distributed-a) amount))
    )
    (begin
      ;; only authorized contracts can inject rewards for A
      (asserts! (or (is-eq contract-caller .street-controller)
                    (is-eq contract-caller .street-market)
                    (is-eq contract-caller .street-rewards)) ERR_NOT_AUTHORIZED)
      (asserts! (> amount u0) ERR_ZERO_AMOUNT)
      
      ;; persist the new global index for token-a
      (var-set global-index-a new-index)
      
      ;; bump total-distributed-a to reflect the newly added WELSH
      (var-set total-distributed-a new-rewards)
      
      (ok true)
    )
  )
)
 
;; add STREET rewards into the index for token-b
(define-public (update-rewards-b (amount uint))
  (let (
 
      ;; total current CREDIT supply used to split rewards pro‑rata
      (total-lp (unwrap-panic (contract-call? .credit-token get-total-supply)))
      
      ;; current global index for token-b before adding this amount
      (current-index (var-get global-index-b))
      
      ;; index increment = amount / total CREDIT (scaled by PRECISION)
      (index-increment (if (> total-lp u0)
        (/ (* amount PRECISION) total-lp)
        u0))
      
      ;; updated global index for token-b after this reward injection
      (new-index (+ current-index index-increment))
      
      ;; updated on-chain accounting total of all STREET ever distributed
      (new-rewards (+ (var-get total-distributed-b) amount))
    )
    (begin
      ;; only authorized contracts can inject rewards for B
      (asserts! (or (is-eq contract-caller .street-market)
                    (is-eq contract-caller .street-rewards)
                    (is-eq contract-caller .emission-controller)) ERR_NOT_AUTHORIZED)
      (asserts! (> amount u0) ERR_ZERO_AMOUNT)
      
      ;; persist the new global index for token-b
      (var-set global-index-b new-index)
      
      ;; bump total-distributed-b to reflect the newly added STREET
      (var-set total-distributed-b new-rewards)
      
      (ok true)
    )
  )
)

(define-public (cleanup-rewards)
  (let (
    ;; compute true pool balances vs. accounting state
    (cleanup-data (unwrap! (calculate-cleanup-rewards) ERR_CLEANUP_DATA))
    (cleanup-a (get cleanup-a cleanup-data))
    (cleanup-b (get cleanup-b cleanup-data))
    (last-cleanup (var-get last-cleanup-block))
  )
    (begin
      ;; enforce minimum interval between cleanup calls
      (asserts! (>= burn-block-height (+ last-cleanup CLEANUP_INTERVAL)) 
        ERR_CLEANUP_INTERVAL)
 
      ;; if there is extra WELSH, fold it back into rewards
      (if (> cleanup-a u0)
        (try! (as-contract? ()
          (try! (update-rewards-a cleanup-a))))
        true)
      
      ;; if there is extra STREET, fold it back into rewards
      (if (> cleanup-b u0)
        (try! (as-contract? ()
          (try! (update-rewards-b cleanup-b))))
        true)
      
      ;; record block height of this cleanup
      (var-set last-cleanup-block burn-block-height)
      
      (ok {
        amount-a: cleanup-a,
        amount-b: cleanup-b,
      })
    )
  )
)

(define-private (calculate-cleanup-rewards)
  (let (
 
    ;; token balances held by the street-rewards contract
    (actual-a (unwrap! (contract-call? .welshcorgicoin get-balance .street-rewards) ERR_BALANCE))
    (actual-b (unwrap! (contract-call? .street-token get-balance .street-rewards) ERR_BALANCE))
    
    ;; totals already claimed by users for each token
    (claimed-a (var-get total-claimed-a))
    (claimed-b (var-get total-claimed-b))
    
    ;; totals of all rewards added for each token (all sources)
    (distributed-a (var-get total-distributed-a))
    (distributed-b (var-get total-distributed-b))
    
    ;; cutoff below which tiny outstanding amounts are treated as dust
    ;; dust-threshold is an absolute amount in token units (0.01)
    (dust-threshold u10000)
    
    ;; amounts that accounting expects to still be in the pool
    (outstanding-a (- distributed-a claimed-a))
    (outstanding-b (- distributed-b claimed-b))
    
    ;; rewards to sweep back into the index math
    (cleanup-a (if (> actual-a outstanding-a)
                  (- actual-a outstanding-a)
                  (if (and (is-eq actual-a outstanding-a)
                          (< outstanding-a dust-threshold))
                      actual-a
                      u0)))
    (cleanup-b (if (> actual-b outstanding-b)
                  (- actual-b outstanding-b)
                  (if (and (is-eq actual-b outstanding-b)
                          (< outstanding-b dust-threshold))
                      actual-b
                      u0)))
  )
    (ok {
      actual-a: actual-a,
      actual-b: actual-b,
      claimed-a: claimed-a,
      claimed-b: claimed-b,
      cleanup-a: cleanup-a,
      cleanup-b: cleanup-b,
      distributed-a: distributed-a,
      distributed-b: distributed-b,
      outstanding-a: outstanding-a,
      outstanding-b: outstanding-b
    })
  )
)