PaymentBridge

;; A simple escrow system for secure peer-to-peer transactions
;; TrustBridge: P2P Trust and Payment Protocol

(define-constant CONTRACT-OWNER tx-sender)
(define-constant ERR-NO-AUTH (err u1))
(define-constant ERR-LOW-VALUE (err u2))
(define-constant ERR-INVALID-USER (err u3))
(define-constant ERR-NO-PAYMENT (err u4))
(define-constant ADMIN tx-sender)
(define-constant ERR-NOT-AUTHORIZED (err u100))
(define-constant ERR-ZERO-AMOUNT (err u101))
(define-constant ERR-SELF-DEAL (err u102))
(define-constant ERR-DEAL-NOT-EXIST (err u103))
(define-constant ERR-BAD-RATING (err u104))
(define-constant ERR-INVALID-DEAL-ID (err u105))

;; Basic payment storage
(define-map payments 
  { id: uint }
  {
    from: principal,
    to: principal,
    amount: uint,
    is-complete: bool,
    created-at: uint
  }
)
;; Check if deal parties are different
(define-private (validate-counterparty (counterparty principal))
  (and 
    (not (is-eq counterparty tx-sender))
    (not (is-eq counterparty ADMIN))
  )
)

;; Payment counter
(define-data-var payment-id-counter uint u1)
;; (define-data-var user principal 'SP3X1Q4Z2F5J7Y6G9K8H9F5J4D5J4D5J4D5J4D5J4D5J4D)
(define-private (validate-deal-id (deal-id uint))
  (and 
    (> deal-id u0)
    (< deal-id (var-get deal-counter))
  )
)

;; ;; Create new payment
;; (define-public (create-payment 
;;   (recipient principal) 
;;   (amount uint)))
;; Deal storage
(define-map deals 
  { deal-id: uint }
  {
    initiator: principal,
    counterparty: principal,
    value: uint,
    state: (string-ascii 20),
    timestamp: uint,
    trust-score: uint
  }
)

;; Trust profiles
(define-map trust-profiles 
  { address: principal }
  { cumulative-score: uint, deal-count: uint }
)

;; Deal counter
(define-data-var deal-counter uint u1)


;; Check if user is valid
(define-private (is-valid-user (recipient principal))
  (and 
    (not (is-eq recipient tx-sender))
    (not (is-eq recipient ADMIN))
  )
)

;; Initiate new deal
(define-public (initiate-deal 
  (counterparty principal) 
  (value uint)
)
  (begin
    (asserts! (is-valid-user counterparty) ERR-INVALID-USER)
    (asserts! (> value u0) ERR-LOW-VALUE)
    ;; Validate counterparty
    (asserts! (validate-counterparty counterparty) ERR-SELF-DEAL)

    ;; Validate value
    (asserts! (> value u0) ERR-ZERO-AMOUNT)

    (let 
      (
        (id (var-get payment-id-counter))
        (current-deal-id (var-get deal-counter))
      )
      (var-set payment-id-counter (+ id u1))
      ;; Update deal counter
      (var-set deal-counter (+ current-deal-id u1))

      (map-set payments 
        { id: id }
        {
          from: tx-sender,
          to: counterparty,
          amount: value,
          is-complete: false,
          created-at: stacks-block-height
        }
      )
      
      ;; Record deal
      (map-set deals 
        { deal-id: current-deal-id }
        {
          initiator: tx-sender,
          counterparty: counterparty,
          value: value,
          state: "OPEN",
          timestamp: stacks-block-height,
          trust-score: u0
        }
      )

      (ok current-deal-id)
    )
  )
)

;; Complete payment
(define-public (complete-payment (payment-id uint))
  (let 
    (
      (payment (unwrap! (map-get? payments { id: payment-id }) ERR-NO-PAYMENT))
    )
    (asserts! (is-eq tx-sender (get from payment)) ERR-NO-AUTH)

    ;; Process the payment
    (try! (stx-transfer? 
      (get amount payment) 
      tx-sender 
      (get to payment)
    ))
    
    ;; Update payment status
    (map-set payments 
      { id: payment-id }
      (merge payment { is-complete: true })
    )
    
    ;; Return success
    (ok true)
  )
)

;; Add trust rating
(define-public (rate-counterparty 
  (deal-id uint) 
  (rating uint)
)
  (begin
    ;; Validate deal
    (asserts! (validate-deal-id deal-id) ERR-INVALID-DEAL-ID)

    (let 
      (
        (deal (unwrap! 
          (map-get? deals { deal-id: deal-id }) 
          ERR-DEAL-NOT-EXIST
        ))
        (initiator (get initiator deal))
        (counterparty (get counterparty deal))
      )
      ;; Verify rater
      (asserts! 
        (is-eq tx-sender counterparty) 
        ERR-NOT-AUTHORIZED
      )
      (asserts! (> rating u0) ERR-BAD-RATING)

      ;; Update trust profile
      (map-set trust-profiles 
        { address: initiator }
        {
          cumulative-score: (+ 
            (get cumulative-score 
              (default-to 
                { cumulative-score: u0, deal-count: u0 } 
                (map-get? trust-profiles { address: initiator })
              )
            )
            rating
          ),
          deal-count: (+ 
            (get deal-count 
              (default-to 
                { cumulative-score: u0, deal-count: u0 } 
                (map-get? trust-profiles { address: initiator })
              )
            )
            u1
          )
        }
      )

      ;; Update deal rating
      (map-set deals 
        { deal-id: deal-id }
        (merge deal { trust-score: rating })
      )

      (ok true)
    )
  )
)

;; Query trust profile
(define-read-only (get-trust-profile (address principal))
  (default-to 
    { cumulative-score: u0, deal-count: u0 }
    (map-get? trust-profiles { address: address })
  )
)

;; Get payment details
(define-read-only (get-payment-info (payment-id uint))
  (map-get? payments { id: payment-id }))
;; Query deal information
(define-read-only (get-deal-info (deal-id uint))
  (map-get? deals { deal-id: deal-id })
)