Stx-trademint

;; TradeMint - Decentralized Trading Platform
;; A platform for trading digital assets with secure escrow capabilities

;; Constants
(define-constant contract-owner tx-sender)
(define-constant err-not-authorized (err u100))
(define-constant err-listing-not-found (err u101))
(define-constant err-invalid-status (err u102))
(define-constant err-insufficient-balance (err u103))
(define-constant err-no-active-offer (err u104))
(define-constant err-listing-expired (err u105))
(define-constant err-invalid-amount (err u106))
(define-constant err-offer-not-found (err u107))
(define-constant err-listing-closed (err u108))
(define-constant err-already-has-offer (err u109))

;; Data Variables
(define-map listings
    uint
    {
        seller: principal,
        asset: (string-ascii 32),
        price: uint,
        status: (string-ascii 10),
        expiry: uint,
        created-at: uint
    }
)

(define-map offers
    {listing-id: uint, buyer: principal}
    {
        amount: uint,
        status: (string-ascii 10),
        created-at: uint
    }
)

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

;; Events
(define-data-var event-id uint u0)

(define-private (emit-event (event-type (string-ascii 20)) (listing-id uint) (principal-data (optional principal)))
    (begin
        (var-set event-id (+ (var-get event-id) u1))
        (print {event-id: (var-get event-id), event-type: event-type, listing-id: listing-id, principal: principal-data})
    )
)

;; Private Functions
(define-private (increment-nonce)
    (begin
        (var-set listing-nonce (+ (var-get listing-nonce) u1))
        (ok (var-get listing-nonce))
    )
)


(define-private (is-listing-active (listing {seller: principal, asset: (string-ascii 32), price: uint, status: (string-ascii 10), expiry: uint, created-at: uint}))
    (and
        (is-eq (get status listing) "active")
        (< stacks-block-time (get expiry listing))
    )
)


;; Public Functions  
(define-public (create-listing (asset (string-ascii 32)) (price uint) (expiry uint))
    (let
        (
            (current-block stacks-block-time)
            (new-id (var-get listing-nonce))
        )
        ;; Increment the nonce first
        (var-set listing-nonce (+ new-id u1))
        
        ;; Validate parameters
        (asserts! (> expiry current-block) (err err-invalid-status))
        (asserts! (> price u0) (err err-invalid-amount))
        
        ;; Create the listing
        (map-insert listings
            new-id
            {
                seller: tx-sender,
                asset: asset,
                price: price,
                status: "active",
                expiry: expiry,
                created-at: current-block
            }
        )
        (emit-event "listing-created" new-id none)
        (ok new-id)
    )
)


(define-public (cancel-listing (listing-id uint))
    (let
        (
            (listing (unwrap! (map-get? listings listing-id) (err err-listing-not-found)))
        )
        (asserts! (is-eq (get seller listing) tx-sender) (err err-not-authorized))
        (asserts! (is-eq (get status listing) "active") (err err-invalid-status))
        
        (map-set listings listing-id
            (merge listing {status: "cancelled"})
        )
        (emit-event "listing-cancelled" listing-id none)
        (ok true)
    )
)



;; Admin function to recover expired listings and refund related offers
(define-public (cleanup-expired-listing (listing-id uint))
    (let
        (
            (listing (unwrap! (map-get? listings listing-id) (err err-listing-not-found)))
        )
        ;; Verify listing is expired and still active
        (asserts! (and (>= stacks-block-time (get expiry listing))
                      (is-eq (get status listing) "active"))
                 (err err-invalid-status))
        
        ;; Mark listing as expired
        (map-set listings
            listing-id
            (merge listing {status: "expired"})
        )
        
        (emit-event "listing-expired" listing-id none)
        (ok true)
    )
)

;; Read-only functions
(define-read-only (get-listing (listing-id uint))
    (map-get? listings listing-id)
)

(define-read-only (get-offer (listing-id uint) (buyer principal))
    (map-get? offers {listing-id: listing-id, buyer: buyer})
)

(define-read-only (get-listing-count)
    (var-get listing-nonce)
)

(define-read-only (is-expired (listing-id uint))
    (match (map-get? listings listing-id)
        listing (>= stacks-block-time (get expiry listing))
        false
    )
)