strade-stx-contracts 1.0.0 → 1.0.1

package/CoreMarketPlace.clar

@@ -0,0 +1,227 @@
+;; CoreMarketPlace Contract
+;; This contract manages the creation, updating, and purchasing of listings in the Strade decentralized marketplace.
+;; It handles the core logic for marketplace interactions, including listing management and purchase fulfillment.
+
+;; --- Constants ---
+;; Defines immutable values used throughout the contract for error handling and configuration.
+
+(define-constant CONTRACT_OWNER tx-sender) ;; Sets the contract deployer as the owner.
+(define-constant ERR_NOT_AUTHORIZED (err u100)) ;; Error for unauthorized actions.
+(define-constant ERR_LISTING_NOT_FOUND (err u101)) ;; Error when a listing cannot be found.
+(define-constant ERR_INVALID_PRICE (err u102)) ;; Error for invalid listing prices (e.g., zero or negative).
+(define-constant ERR_INVALID_SELLER (err u103)) ;; Error for invalid seller principals.
+(define-constant ERR_INSUFFICIENT_BALANCE (err u104)) ;; Error when a buyer has insufficient funds.
+(define-constant ERR_LISTING_EXPIRED (err u105)) ;; Error for expired listings.
+(define-constant ERR_INVALID_STATUS (err u106)) ;; Error for invalid listing statuses.
+(define-constant ERR_NOT_SELLER (err u107)) ;; Error when a user is not the seller of a listing.
+(define-constant ERR_ALREADY_PURCHASED (err u108)) ;; Error for listings that have already been sold.
+(define-constant ERR_INVALID_INPUT (err u109)) ;; Error for invalid input parameters.
+(define-constant ERR_INVALID_DURATION (err u110)) ;; Error for invalid listing durations.
+(define-constant ERR_INVALID_LISTING_ID (err u111)) ;; Error for invalid listing IDs.
+(define-constant MAX_LISTING_DURATION u52560) ;; Maximum duration of a listing (approximately 1 year).
+
+;; --- Data Maps ---
+;; Defines the data structures used to store marketplace information.
+
+(define-map Listings
+  { listing-id: uint }
+  {
+    seller: principal, ;; The principal of the seller.
+    name: (string-utf8 64), ;; The name of the listing.
+    description: (string-utf8 256), ;; A description of the item.
+    price: uint, ;; The price of the listing in micro-STX.
+    status: (string-ascii 20), ;; The current status of the listing (e.g., "active", "sold", "cancelled").
+    created-at: uint, ;; The block height at which the listing was created.
+    expires-at: uint ;; The block height at which the listing expires.
+  }
+)
+
+;; --- Variables ---
+;; Defines mutable variables for tracking the contract's state.
+
+(define-data-var last-listing-id uint u0) ;; Tracks the ID of the last created listing.
+
+;; --- Private Functions ---
+;; Helper functions intended for internal use by the contract.
+
+;; Checks if a given price is valid (greater than zero).
+(define-private (is-valid-price (price uint))
+  (> price u0)
+)
+
+;; Checks if a seller principal is valid (not the sender or the contract itself).
+(define-private (is-valid-seller (seller principal))
+  (and 
+    (not (is-eq seller tx-sender))
+    (not (is-eq seller (as-contract tx-sender)))
+  )
+)
+
+;; Checks if a string is within the specified length constraints.
+(define-private (is-valid-string (str (string-utf8 256)) (max-len uint))
+  (and (>= (len str) u1) (<= (len str) max-len))
+)
+
+;; Checks if a listing duration is valid.
+(define-private (is-valid-duration (duration uint))
+  (and (> duration u0) (<= duration MAX_LISTING_DURATION))
+)
+
+;; Checks if a listing ID is valid.
+(define-private (is-valid-listing-id (id uint))
+  (<= id (var-get last-listing-id))
+)
+
+;; Increments and returns the next listing ID.
+(define-private (increment-listing-id)
+  (let 
+    (
+      (current-id (var-get last-listing-id))
+    )
+    (var-set last-listing-id (+ current-id u1))
+    (var-get last-listing-id)
+  )
+)
+
+;; --- Public Functions ---
+;; Functions that can be called by any user.
+
+;; Creates a new listing in the marketplace.
+;; @param name: The name of the listing.
+;; @param description: A description of the item.
+;; @param price: The price of the listing in micro-STX.
+;; @param duration: The duration of the listing in blocks.
+;; @returns (ok uint): The ID of the newly created listing.
+(define-public (create-listing (name (string-utf8 64)) (description (string-utf8 256)) (price uint) (duration uint))
+  (let
+    (
+      (listing-id (increment-listing-id))
+      (expires-at (+ stacks-block-height duration))
+    )
+    (asserts! (is-valid-price price) (err ERR_INVALID_PRICE))
+    (asserts! (is-valid-string name u64) (err ERR_INVALID_INPUT))
+    (asserts! (is-valid-string description u256) (err ERR_INVALID_INPUT))
+    (asserts! (is-valid-duration duration) (err ERR_INVALID_DURATION))
+    (map-set Listings
+      { listing-id: listing-id }
+      {
+        seller: tx-sender,
+        name: name,
+        description: description,
+        price: price,
+        status: "active",
+        created-at: stacks-block-height,
+        expires-at: expires-at
+      }
+    )
+    (print { event: "listing_created", listing-id: listing-id, seller: tx-sender })
+    (ok listing-id)
+  )
+)
+
+;; Updates an existing listing.
+;; @param listing-id: The ID of the listing to update.
+;; @param new-price: The new price for the listing.
+;; @param new-description: The new description for the listing.
+;; @returns (ok bool): True if the update is successful.
+(define-public (update-listing (listing-id uint) (new-price uint) (new-description (string-utf8 256)))
+  (begin
+    (asserts! (is-valid-listing-id listing-id) (err ERR_INVALID_LISTING_ID))
+    (let
+      (
+        (listing (unwrap! (map-get? Listings { listing-id: listing-id }) (err ERR_LISTING_NOT_FOUND)))
+      )
+      (asserts! (is-eq (get seller listing) tx-sender) (err ERR_NOT_SELLER))
+      (asserts! (is-eq (get status listing) "active") (err ERR_INVALID_STATUS))
+      (asserts! (is-valid-price new-price) (err ERR_INVALID_PRICE))
+      (asserts! (is-valid-string new-description u256) (err ERR_INVALID_INPUT))
+      (map-set Listings
+        { listing-id: listing-id }
+        (merge listing 
+          {
+            price: new-price,
+            description: new-description
+          }
+        )
+      )
+      (print { event: "listing_updated", listing-id: listing-id, seller: tx-sender })
+      (ok true)
+    )
+  )
+)
+
+;; Cancels a listing.
+;; @param listing-id: The ID of the listing to cancel.
+;; @returns (ok bool): True if the cancellation is successful.
+(define-public (cancel-listing (listing-id uint))
+  (begin
+    (asserts! (is-valid-listing-id listing-id) (err ERR_INVALID_LISTING_ID))
+    (let
+      (
+        (listing (unwrap! (map-get? Listings { listing-id: listing-id }) (err ERR_LISTING_NOT_FOUND)))
+      )
+      (asserts! (is-eq (get seller listing) tx-sender) (err ERR_NOT_SELLER))
+      (asserts! (is-eq (get status listing) "active") (err ERR_INVALID_STATUS))
+      (map-set Listings
+        { listing-id: listing-id }
+        (merge listing { status: "cancelled" })
+      )
+      (print { event: "listing_cancelled", listing-id: listing-id, seller: tx-sender })
+      (ok true)
+    )
+  )
+)
+
+;; Purchases a listing.
+;; @param listing-id: The ID of the listing to purchase.
+;; @returns (ok bool): True if the purchase is successful.
+(define-public (purchase-listing (listing-id uint))
+  (begin
+    (asserts! (is-valid-listing-id listing-id) (err ERR_INVALID_LISTING_ID))
+    (let
+      (
+        (listing (unwrap! (map-get? Listings { listing-id: listing-id }) (err ERR_LISTING_NOT_FOUND)))
+        (price (get price listing))
+        (seller (get seller listing))
+      )
+      (asserts! (is-eq (get status listing) "active") (err ERR_INVALID_STATUS))
+      (asserts! (<= stacks-block-height (get expires-at listing)) (err ERR_LISTING_EXPIRED))
+      (asserts! (is-valid-seller seller) (err ERR_INVALID_SELLER))
+      (match (stx-transfer? price tx-sender seller)
+        success (begin
+          (map-set Listings
+            { listing-id: listing-id }
+            (merge listing { status: "sold" })
+          )
+          (print { event: "listing_purchased", listing-id: listing-id, buyer: tx-sender, seller: seller, price: price })
+          (ok true))
+        error (err ERR_INSUFFICIENT_BALANCE))
+    )
+  )
+)
+
+;; --- Read-Only Functions ---
+;; Functions for retrieving data from the contract without making state changes.
+
+;; Retrieves a listing by its ID.
+;; @param listing-id: The ID of the listing to retrieve.
+;; @returns (optional {<listing-data>}): The listing data or none if not found.
+(define-read-only (get-listing (listing-id uint))
+  (if (is-valid-listing-id listing-id)
+    (map-get? Listings { listing-id: listing-id })
+    none
+  )
+)
+
+;; Retrieves the ID of the last created listing.
+;; @returns (ok uint): The last listing ID.
+(define-read-only (get-last-listing-id)
+  (ok (var-get last-listing-id))
+)
+
+;; --- Contract Initialization ---
+;; Initializes the contract upon deployment.
+(begin
+  (print "CoreMarketPlace contract initialized")
+  (ok true)
+)

package/DisputeResolution_clar.clar

@@ -0,0 +1,265 @@
+;; DisputeResolution Contract
+;; This contract handles the dispute resolution process for the Strade marketplace.
+;; It allows users to raise disputes, arbitrators to vote on them, and resolves disputes based on the outcome.
+
+;; --- Constants ---
+;; Defines immutable values used throughout the contract for error handling and configuration.
+
+(define-constant CONTRACT_OWNER tx-sender) ;; Sets the contract deployer as the owner.
+(define-constant ERR_NOT_AUTHORIZED (err u100)) ;; Error for unauthorized actions.
+(define-constant ERR_DISPUTE_NOT_FOUND (err u101)) ;; Error when a dispute cannot be found.
+(define-constant ERR_INVALID_STATE (err u102)) ;; Error for invalid dispute states.
+(define-constant ERR_NOT_ARBITRATOR (err u103)) ;; Error when a user is not an authorized arbitrator.
+(define-constant ERR_ALREADY_VOTED (err u104)) ;; Error if an arbitrator has already voted.
+(define-constant ERR_VOTING_CLOSED (err u105)) ;; Error when voting on a dispute is closed.
+(define-constant ERR_INSUFFICIENT_VOTES (err u106)) ;; Error if there are not enough votes to resolve a dispute.
+(define-constant ERR_INVALID_VOTE (err u107)) ;; Error for invalid vote values.
+(define-constant ERR_NOT_INVOLVED_PARTY (err u108)) ;; Error when a user is not a party to the dispute.
+(define-constant ERR_INVALID_ESCROW_ID (err u109)) ;; Error for invalid escrow IDs.
+(define-constant ERR_INVALID_REASON (err u110)) ;; Error for invalid dispute reasons.
+(define-constant ERR_INVALID_DISPUTE_ID (err u111)) ;; Error for invalid dispute IDs.
+(define-constant ERR_INVALID_REWARD (err u112)) ;; Error for invalid arbitrator rewards.
+(define-constant ERR_INVALID_PRINCIPAL (err u113)) ;; Error for invalid principal addresses.
+(define-constant VOTING_PERIOD u144) ;; The duration of the voting period in blocks (approximately 24 hours).
+(define-constant MIN_VOTES_REQUIRED u3) ;; The minimum number of votes required to resolve a dispute.
+
+;; --- Data Maps ---
+;; Defines the data structures used to store dispute and arbitrator information.
+
+(define-map Disputes
+  { dispute-id: uint }
+  {
+    escrow-id: uint, ;; The ID of the associated escrow.
+    initiator: principal, ;; The principal who initiated the dispute.
+    counterparty: principal, ;; The other party in the dispute.
+    reason: (string-utf8 256), ;; The reason for the dispute.
+    status: (string-ascii 20), ;; The current status of the dispute (e.g., "open", "resolved").
+    created-at: uint, ;; The block height at which the dispute was created.
+    votes-for: uint, ;; The number of votes in favor of the initiator.
+    votes-against: uint, ;; The number of votes against the initiator.
+    resolution: (optional (string-ascii 20)) ;; The resolution of the dispute.
+  }
+)
+
+(define-map Arbitrators principal bool) ;; Stores the set of authorized arbitrators.
+(define-map ArbitratorVotes { dispute-id: uint, arbitrator: principal } bool) ;; Tracks votes cast by arbitrators.
+
+;; --- Variables ---
+;; Defines mutable variables for tracking the contract's state.
+
+(define-data-var last-dispute-id uint u0) ;; Tracks the ID of the last created dispute.
+(define-data-var arbitrator-reward uint u100) ;; The reward amount for arbitrators who vote on a dispute.
+
+;; --- Private Functions ---
+;; Helper functions intended for internal use by the contract.
+
+;; Checks if a given user is an authorized arbitrator.
+(define-private (is-arbitrator (user principal))
+  (default-to false (map-get? Arbitrators user))
+)
+
+;; Checks if an arbitrator has already voted on a specific dispute.
+(define-private (has-voted (dispute-id uint) (arbitrator principal))
+  (is-some (map-get? ArbitratorVotes { dispute-id: dispute-id, arbitrator: arbitrator }))
+)
+
+;; Updates the vote count for a dispute.
+(define-private (update-vote-count (dispute-id uint) (vote bool))
+  (match (map-get? Disputes { dispute-id: dispute-id })
+    dispute (let
+      (
+        (new-votes-for (if vote (+ (get votes-for dispute) u1) (get votes-for dispute)))
+        (new-votes-against (if vote (get votes-against dispute) (+ (get votes-against dispute) u1)))
+      )
+      (map-set Disputes { dispute-id: dispute-id }
+        (merge dispute {
+          votes-for: new-votes-for,
+          votes-against: new-votes-against
+        }))
+      (ok true))
+    (err ERR_DISPUTE_NOT_FOUND)
+  )
+)
+
+;; Checks if an escrow ID is valid.
+(define-private (is-valid-escrow-id (escrow-id uint))
+  (> escrow-id u0)
+)
+
+;; Checks if a dispute reason is valid.
+(define-private (is-valid-reason (reason (string-utf8 256)))
+  (and (> (len reason) u0) (<= (len reason) u256))
+)
+
+;; Checks if a dispute ID is valid.
+(define-private (is-valid-dispute-id (dispute-id uint))
+  (<= dispute-id (var-get last-dispute-id))
+)
+
+;; --- Public Functions ---
+;; Functions that can be called by any user.
+
+;; Raises a new dispute.
+;; @param escrow-id: The ID of the escrow to dispute.
+;; @param counterparty: The other party in the dispute.
+;; @param reason: The reason for the dispute.
+;; @returns (ok uint): The ID of the newly created dispute.
+(define-public (raise-dispute (escrow-id uint) (counterparty principal) (reason (string-utf8 256)))
+  (let
+    (
+      (dispute-id (+ (var-get last-dispute-id) u1))
+    )
+    (asserts! (is-valid-escrow-id escrow-id) (err ERR_INVALID_ESCROW_ID))
+    (asserts! (is-valid-reason reason) (err ERR_INVALID_REASON))
+    (asserts! (not (is-eq tx-sender counterparty)) (err ERR_NOT_INVOLVED_PARTY))
+    (map-set Disputes
+      { dispute-id: dispute-id }
+      {
+        escrow-id: escrow-id,
+        initiator: tx-sender,
+        counterparty: counterparty,
+        reason: reason,
+        status: "open",
+        created-at: stacks-block-height,
+        votes-for: u0,
+        votes-against: u0,
+        resolution: none
+      }
+    )
+    (var-set last-dispute-id dispute-id)
+    (print { event: "dispute_raised", dispute-id: dispute-id, escrow-id: escrow-id, initiator: tx-sender })
+    (ok dispute-id)
+  )
+)
+
+;; Allows an arbitrator to vote on a dispute.
+;; @param dispute-id: The ID of the dispute to vote on.
+;; @param vote: The arbitrator's vote (true for initiator, false for counterparty).
+;; @returns (ok bool): True if the vote is successful.
+(define-public (vote-on-dispute (dispute-id uint) (vote bool))
+  (let
+    (
+      (dispute (unwrap! (map-get? Disputes { dispute-id: dispute-id }) (err ERR_DISPUTE_NOT_FOUND)))
+    )
+    (asserts! (is-valid-dispute-id dispute-id) (err ERR_INVALID_DISPUTE_ID))
+    (asserts! (is-arbitrator tx-sender) (err ERR_NOT_ARBITRATOR))
+    (asserts! (is-eq (get status dispute) "open") (err ERR_VOTING_CLOSED))
+    (asserts! (<= (- stacks-block-height (get created-at dispute)) VOTING_PERIOD) (err ERR_VOTING_CLOSED))
+    (asserts! (not (has-voted dispute-id tx-sender)) (err ERR_ALREADY_VOTED))
+    (try! (update-vote-count dispute-id vote))
+    (map-set ArbitratorVotes { dispute-id: dispute-id, arbitrator: tx-sender } vote)
+    (print { event: "arbitrator_voted", dispute-id: dispute-id, arbitrator: tx-sender, vote: vote })
+    (ok true)
+  )
+)
+
+;; Resolves a dispute based on the votes.
+;; @param dispute-id: The ID of the dispute to resolve.
+;; @returns (ok (string-ascii 20)): The resolution of the dispute.
+(define-public (resolve-dispute (dispute-id uint))
+  (let
+    (
+      (dispute (unwrap! (map-get? Disputes { dispute-id: dispute-id }) (err ERR_DISPUTE_NOT_FOUND)))
+    )
+    (asserts! (is-valid-dispute-id dispute-id) (err ERR_INVALID_DISPUTE_ID))
+    (asserts! (is-eq (get status dispute) "open") (err ERR_INVALID_STATE))
+    (asserts! (>= (+ (get votes-for dispute) (get votes-against dispute)) MIN_VOTES_REQUIRED) (err ERR_INSUFFICIENT_VOTES))
+    (asserts! (<= (- stacks-block-height (get created-at dispute)) VOTING_PERIOD) (err ERR_VOTING_CLOSED))
+    (let
+      (
+        (resolution (if (> (get votes-for dispute) (get votes-against dispute)) "for_initiator" "for_counterparty"))
+      )
+      (map-set Disputes { dispute-id: dispute-id }
+        (merge dispute {
+          status: "resolved",
+          resolution: (some resolution)
+        })
+      )
+      (print { event: "dispute_resolved", dispute-id: dispute-id, resolution: resolution })
+      (ok resolution)
+    )
+  )
+)
+
+;; Adds a new arbitrator.
+;; @param arbitrator: The principal of the new arbitrator.
+;; @returns (ok bool): True if the arbitrator is added successfully.
+(define-public (add-arbitrator (arbitrator principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+    (asserts! (is-valid-principal arbitrator) (err ERR_INVALID_PRINCIPAL))
+    (map-set Arbitrators arbitrator true)
+    (print { event: "arbitrator_added", arbitrator: arbitrator })
+    (ok true)
+  )
+)
+
+;; Removes an arbitrator.
+;; @param arbitrator: The principal of the arbitrator to remove.
+;; @returns (ok bool): True if the arbitrator is removed successfully.
+(define-public (remove-arbitrator (arbitrator principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+    (asserts! (is-valid-principal arbitrator) (err ERR_INVALID_PRINCIPAL))
+    (map-delete Arbitrators arbitrator)
+    (print { event: "arbitrator_removed", arbitrator: arbitrator })
+    (ok true)
+  )
+)
+
+;; Sets the reward for arbitrators.
+;; @param new-reward: The new reward amount.
+;; @returns (ok bool): True if the reward is set successfully.
+(define-public (set-arbitrator-reward (new-reward uint))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+    (asserts! (> new-reward u0) (err ERR_INVALID_REWARD))
+    (var-set arbitrator-reward new-reward)
+    (print { event: "arbitrator_reward_set", new-reward: new-reward })
+    (ok true)
+  )
+)
+
+;; --- Read-Only Functions ---
+;; Functions for retrieving data from the contract without making state changes.
+
+;; Retrieves a dispute by its ID.
+;; @param dispute-id: The ID of the dispute to retrieve.
+;; @returns (optional {<dispute-data>}): The dispute data or none if not found.
+(define-read-only (get-dispute (dispute-id uint))
+  (map-get? Disputes { dispute-id: dispute-id })
+)
+
+;; Retrieves the ID of the last created dispute.
+;; @returns (ok uint): The last dispute ID.
+(define-read-only (get-last-dispute-id)
+  (ok (var-get last-dispute-id))
+)
+
+;; Retrieves the arbitrator reward amount.
+;; @returns (ok uint): The arbitrator reward amount.
+(define-read-only (get-arbitrator-reward)
+  (ok (var-get arbitrator-reward))
+)
+
+;; Checks if a user is an authorized arbitrator.
+;; @param user: The principal to check.
+;; @returns (ok bool): True if the user is an arbitrator.
+(define-read-only (is-user-arbitrator (user principal))
+  (ok (is-arbitrator user))
+)
+
+;; --- Helper function for principal validation ---
+(define-private (is-valid-principal (principal principal))
+  (and 
+    (not (is-eq principal CONTRACT_OWNER))
+    (not (is-eq principal (as-contract tx-sender)))
+  )
+)
+
+;; --- Contract Initialization ---
+;; Initializes the contract upon deployment.
+(begin
+  (print "DisputeResolution contract initialized")
+  (ok true)
+)

package/EscrowService.clar

@@ -0,0 +1,171 @@
+;; EscrowService Contract
+;; This contract provides a secure escrow service for transactions between buyers and sellers.
+;; It holds funds until the buyer releases them to the seller or a dispute is resolved.
+
+;; --- Constants ---
+;; Defines immutable values used throughout the contract for error handling and configuration.
+
+(define-constant CONTRACT_OWNER tx-sender) ;; Sets the contract deployer as the owner.
+(define-constant ERR_NOT_AUTHORIZED (err u100)) ;; Error for unauthorized actions.
+(define-constant ERR_ESCROW_NOT_FOUND (err u101)) ;; Error when an escrow cannot be found.
+(define-constant ERR_ALREADY_RELEASED (err u102)) ;; Error if funds have already been released.
+(define-constant ERR_TRANSFER_FAILED (err u103)) ;; Error for failed STX transfers.
+(define-constant ERR_INVALID_ESCROW_ID (err u104)) ;; Error for invalid escrow IDs.
+(define-constant ERR_INVALID_AMOUNT (err u105)) ;; Error for invalid transaction amounts.
+(define-constant ERR_INVALID_SELLER (err u106)) ;; Error for invalid seller principals.
+(define-constant ERR_ESCROW_EXPIRED (err u107)) ;; Error for expired escrows.
+(define-constant ESCROW_DURATION u1008) ;; The duration of the escrow in blocks (approximately 7 days).
+
+;; --- Data Maps ---
+;; Defines the data structures used to store escrow information.
+
+(define-map Escrows
+  { escrow-id: uint }
+  {
+    buyer: principal, ;; The principal of the buyer.
+    seller: principal, ;; The principal of the seller.
+    amount: uint, ;; The amount of STX held in escrow.
+    state: (string-ascii 10), ;; The current state of the escrow (e.g., "locked", "released", "refunded").
+    created-at: uint, ;; The block height at which the escrow was created.
+    expires-at: uint ;; The block height at which the escrow expires.
+  }
+)
+
+;; --- Variables ---
+;; Defines mutable variables for tracking the contract's state.
+
+(define-data-var last-escrow-id uint u0) ;; Tracks the ID of the last created escrow.
+
+;; --- Helper functions ---
+
+;; Checks if a seller principal is valid.
+(define-private (is-valid-seller (seller principal))
+  (and 
+    (not (is-eq seller tx-sender))
+    (not (is-eq seller (as-contract tx-sender)))
+  )
+)
+
+;; Checks if an escrow ID is valid.
+(define-private (is-valid-escrow-id (escrow-id uint))
+  (<= escrow-id (var-get last-escrow-id))
+)
+
+;; --- Public Functions ---
+
+;; Creates a new escrow.
+;; @param seller: The principal of the seller.
+;; @param amount: The amount of STX to hold in escrow.
+;; @returns (ok uint): The ID of the newly created escrow.
+(define-public (create-escrow (seller principal) (amount uint))
+  (let
+    (
+      (escrow-id (+ (var-get last-escrow-id) u1))
+      (expires-at (+ stacks-block-height ESCROW_DURATION))
+    )
+    (asserts! (> amount u0) (err ERR_INVALID_AMOUNT))
+    (asserts! (is-valid-seller seller) (err ERR_INVALID_SELLER))
+    (match (stx-transfer? amount tx-sender (as-contract tx-sender))
+      success
+        (begin
+          (map-set Escrows
+            { escrow-id: escrow-id }
+            {
+              buyer: tx-sender,
+              seller: seller,
+              amount: amount,
+              state: "locked",
+              created-at: stacks-block-height,
+              expires-at: expires-at
+            }
+          )
+          (var-set last-escrow-id escrow-id)
+          (print {event: "escrow_created", escrow-id: escrow-id, buyer: tx-sender, seller: seller, amount: amount})
+          (ok escrow-id)
+        )
+      error (err ERR_TRANSFER_FAILED)
+    )
+  )
+)
+
+;; Releases funds to the seller.
+;; @param escrow-id: The ID of the escrow to release.
+;; @returns (ok bool): True if the funds are released successfully.
+(define-public (release-funds (escrow-id uint))
+  (begin
+    (asserts! (is-valid-escrow-id escrow-id) (err ERR_INVALID_ESCROW_ID))
+    (let
+      (
+        (escrow (unwrap! (map-get? Escrows { escrow-id: escrow-id }) (err ERR_ESCROW_NOT_FOUND)))
+        (seller (get seller escrow))
+        (amount (get amount escrow))
+      )
+      (asserts! (or (is-eq tx-sender CONTRACT_OWNER) (is-eq tx-sender (get buyer escrow))) (err ERR_NOT_AUTHORIZED))
+      (asserts! (is-eq (get state escrow) "locked") (err ERR_ALREADY_RELEASED))
+      (asserts! (<= stacks-block-height (get expires-at escrow)) (err ERR_ESCROW_EXPIRED))
+      (match (as-contract (stx-transfer? amount tx-sender seller))
+        success 
+          (begin
+            (map-set Escrows
+              { escrow-id: escrow-id }
+              (merge escrow { state: "released" })
+            )
+            (print {event: "funds_released", escrow-id: escrow-id, seller: seller, amount: amount})
+            (ok true)
+          )
+        error (err ERR_TRANSFER_FAILED)
+      )
+    )
+  )
+)
+
+;; Refunds the buyer.
+;; @param escrow-id: The ID of the escrow to refund.
+;; @returns (ok bool): True if the refund is successful.
+(define-public (refund-buyer (escrow-id uint))
+  (begin
+    (asserts! (is-valid-escrow-id escrow-id) (err ERR_INVALID_ESCROW_ID))
+    (let
+      (
+        (escrow (unwrap! (map-get? Escrows { escrow-id: escrow-id }) (err ERR_ESCROW_NOT_FOUND)))
+        (buyer (get buyer escrow))
+        (amount (get amount escrow))
+      )
+      (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+      (asserts! (is-eq (get state escrow) "locked") (err ERR_ALREADY_RELEASED))
+      (match (as-contract (stx-transfer? amount tx-sender buyer))
+        success 
+          (begin
+            (map-set Escrows
+              { escrow-id: escrow-id }
+              (merge escrow { state: "refunded" })
+            )
+            (print {event: "buyer_refunded", escrow-id: escrow-id, buyer: buyer, amount: amount})
+            (ok true)
+          )
+        error (err ERR_TRANSFER_FAILED)
+      )
+    )
+  )
+)
+
+;; --- Read-Only Functions ---
+
+;; Retrieves escrow details by ID.
+;; @param escrow-id: The ID of the escrow to retrieve.
+;; @returns (ok {<escrow-data>}): The escrow data or an error if not found.
+(define-read-only (get-escrow (escrow-id uint))
+  (begin
+    (asserts! (is-valid-escrow-id escrow-id) (err ERR_INVALID_ESCROW_ID))
+    (match (map-get? Escrows { escrow-id: escrow-id })
+      escrow (ok escrow)
+      (err ERR_ESCROW_NOT_FOUND)
+    )
+  )
+)
+
+;; Retrieves the ID of the last created escrow.
+;; @returns (ok uint): The last escrow ID.
+(define-read-only (get-last-escrow-id)
+  (ok (var-get last-escrow-id))
+)

package/UserProfile.clar

@@ -0,0 +1,280 @@
+;; UserProfile Contract
+;; This contract manages user profiles, including usernames, bios, ratings, and reputation scores.
+;; It provides functions for users to register, update their profiles, and rate each other.
+
+;; --- Constants ---
+;; Defines immutable values used throughout the contract for error handling and configuration.
+
+(define-constant CONTRACT_OWNER tx-sender) ;; Sets the contract deployer as the owner.
+(define-constant ERR_NOT_AUTHORIZED (err u100)) ;; Error for unauthorized actions.
+(define-constant ERR_USER_NOT_FOUND (err u101)) ;; Error when a user profile cannot be found.
+(define-constant ERR_INVALID_RATING (err u102)) ;; Error for invalid rating values (must be between 1 and 5).
+(define-constant ERR_SELF_RATING (err u103)) ;; Error when a user attempts to rate themselves.
+(define-constant ERR_ALREADY_REGISTERED (err u104)) ;; Error if a user is already registered.
+(define-constant ERR_INVALID_INPUT (err u105)) ;; Error for invalid input parameters.
+(define-constant ERR_DATA_STORE_FAILURE (err u106)) ;; Error for data storage failures.
+(define-constant ERR_INVALID_PRINCIPAL (err u107)) ;; Error for invalid principal addresses.
+(define-constant ERR_INVALID_USERNAME (err u108)) ;; Error for invalid usernames.
+(define-constant ERR_INVALID_BIO (err u109)) ;; Error for invalid bio lengths.
+(define-constant ERR_INVALID_EMAIL (err u110)) ;; Error for invalid email formats or lengths.
+
+;; --- Data Maps ---
+;; Defines the data structures used to store user profile information.
+
+(define-map Users principal
+  {
+    username: (string-utf8 64), ;; The user's chosen username.
+    bio: (string-utf8 256), ;; A short biography or description.
+    email: (string-utf8 64), ;; The user's email address.
+    registration-date: uint, ;; The block height of the user's registration.
+    total-ratings: uint, ;; The total number of ratings the user has received.
+    rating-sum: uint, ;; The sum of all ratings received.
+    reputation-score: uint ;; A calculated score based on ratings and other factors.
+  }
+)
+
+(define-map UserAuthorization principal bool) ;; Stores authorization status for specific users.
+
+;; --- Private Functions ---
+;; Helper functions for internal contract use.
+
+;; Checks if a string is within the specified length constraints.
+(define-private (is-valid-string (str (string-utf8 256)) (max-len uint))
+  (and (>= (len str) u1) (<= (len str) max-len))
+)
+
+;; Checks if a principal is a valid user address.
+(define-private (is-valid-principal (user principal))
+  (not (is-eq user (as-contract tx-sender)))
+)
+
+;; Validates the format and length of a username.
+(define-private (validate-username (username (string-utf8 64)))
+  (if (is-valid-string username u64)
+    (ok username)
+    (err ERR_INVALID_USERNAME))
+)
+
+;; Validates the length of a user's bio.
+(define-private (validate-bio (bio (string-utf8 256)))
+  (if (is-valid-string bio u256)
+    (ok bio)
+    (err ERR_INVALID_BIO))
+)
+
+;; Validates the format and length of an email address.
+(define-private (validate-email (email (string-utf8 64)))
+  (if (is-valid-string email u64)
+    (ok email)
+    (err ERR_INVALID_EMAIL))
+)
+
+;; Sets the user data in the Users map.
+(define-private (set-user-data (user principal) (data {
+    username: (string-utf8 64),
+    bio: (string-utf8 256),
+    email: (string-utf8 64),
+    registration-date: uint,
+    total-ratings: uint,
+    rating-sum: uint,
+    reputation-score: uint
+  }))
+  (if (map-set Users user data)
+    (ok true)
+    (err ERR_DATA_STORE_FAILURE))
+)
+
+;; --- Read-Only Functions ---
+;; Functions for retrieving data from the contract without making state changes.
+
+;; Retrieves a user's profile.
+;; @param user: The principal of the user to retrieve.
+;; @returns (ok {<user-data>}): The user's profile data or an error if not found.
+(define-read-only (get-user-profile (user principal))
+  (match (map-get? Users user)
+    user-data (ok user-data)
+    (err ERR_USER_NOT_FOUND)))
+
+;; Retrieves a user's average rating.
+;; @param user: The principal of the user.
+;; @returns (ok uint): The user's average rating or 0 if no ratings.
+(define-read-only (get-user-rating (user principal))
+  (match (map-get? Users user)
+    user-data (let (
+      (total-ratings (get total-ratings user-data))
+      (rating-sum (get rating-sum user-data))
+    )
+    (if (> total-ratings u0)
+      (ok (/ rating-sum total-ratings))
+      (ok u0)))
+    (err ERR_USER_NOT_FOUND)
+  )
+)
+
+;; Checks if a user is authorized.
+;; @param user: The principal to check.
+;; @returns (ok bool): True if the user is authorized.
+(define-read-only (is-user-authorized (user principal))
+  (ok (default-to false (map-get? UserAuthorization user))))
+
+
+;; --- Public Functions ---
+;; Functions that can be called by any user.
+
+;; Registers a new user.
+;; @param username: The desired username.
+;; @param bio: A short bio.
+;; @param email: The user's email address.
+;; @returns (ok bool): True if registration is successful.
+(define-public (register-user (username (string-utf8 64)) (bio (string-utf8 256)) (email (string-utf8 64)))
+  (let (
+    (existing-user (map-get? Users tx-sender))
+  )
+  (asserts! (is-none existing-user) (err ERR_ALREADY_REGISTERED))
+  (asserts! (and 
+              (> (len username) u0)
+              (>= (len username) u1)
+              (<= (len username) u64)
+              (> (len bio) u0)
+              (>= (len bio) u1)
+              (<= (len bio) u256)
+              (> (len email) u0)
+              (>= (len email) u1)
+              (<= (len email) u64))
+            (err ERR_INVALID_INPUT))
+  (let (
+    (validated-username (try! (validate-username username)))
+    (validated-bio (try! (validate-bio bio)))
+    (validated-email (try! (validate-email email)))
+  )
+    (match (set-user-data tx-sender
+      {
+        username: validated-username,
+        bio: validated-bio,
+        email: validated-email,
+        registration-date: stacks-block-height,
+        total-ratings: u0,
+        rating-sum: u0,
+        reputation-score: u0
+      })
+      success (ok true)
+      error (err ERR_DATA_STORE_FAILURE))
+  ))
+)
+
+;; Updates a user's profile.
+;; @param bio: The new bio.
+;; @param email: The new email address.
+;; @returns (ok bool): True if the update is successful.
+(define-public (update-profile (bio (string-utf8 256)) (email (string-utf8 64)))
+  (begin
+    (asserts! (and 
+                (> (len bio) u0)
+                (>= (len bio) u1)
+                (<= (len bio) u256)
+                (> (len email) u0)
+                (>= (len email) u1)
+                (<= (len email) u64))
+              (err ERR_INVALID_INPUT))
+    (let (
+      (validated-bio (try! (validate-bio bio)))
+      (validated-email (try! (validate-email email)))
+    )
+      (match (map-get? Users tx-sender)
+        user-data 
+          (match (set-user-data tx-sender
+            (merge user-data
+              {
+                bio: validated-bio,
+                email: validated-email
+              }
+            ))
+            success (ok true)
+            error (err ERR_DATA_STORE_FAILURE))
+        (err ERR_USER_NOT_FOUND)
+      )
+    )
+  )
+)
+
+;; Rates a user.
+;; @param user: The principal of the user to rate.
+;; @param rating: The rating value (1-5).
+;; @returns (ok bool): True if the rating is successful.
+(define-public (rate-user (user principal) (rating uint))
+  (begin
+    (asserts! (is-valid-principal user) (err ERR_INVALID_PRINCIPAL))
+    (asserts! (not (is-eq tx-sender user)) (err ERR_SELF_RATING))
+    (asserts! (and (>= rating u1) (<= rating u5)) (err ERR_INVALID_RATING))
+    (match (map-get? Users user)
+      user-data
+        (match (set-user-data user
+          (merge user-data
+            {
+              total-ratings: (+ (get total-ratings user-data) u1),
+              rating-sum: (+ (get rating-sum user-data) rating)
+            }
+          ))
+          success (ok true)
+          error (err ERR_DATA_STORE_FAILURE))
+      (err ERR_USER_NOT_FOUND)
+    )
+  )
+)
+
+;; Calculates a user's reputation score.
+;; @param user: The principal of the user.
+;; @returns (ok bool): True if the calculation is successful.
+(define-public (calculate-reputation (user principal))
+  (begin
+    (asserts! (is-valid-principal user) (err ERR_INVALID_PRINCIPAL))
+    (match (map-get? Users user)
+      user-data
+        (let (
+          (total-ratings (get total-ratings user-data))
+          (rating-sum (get rating-sum user-data))
+          (avg-rating (if (> total-ratings u0) (/ rating-sum total-ratings) u0))
+          (new-reputation (+ (* avg-rating u20) (* total-ratings u2)))
+        )
+        (match (set-user-data user
+          (merge user-data
+            {
+              reputation-score: new-reputation
+            }
+          ))
+          success (ok true)
+          error (err ERR_DATA_STORE_FAILURE)))
+      (err ERR_USER_NOT_FOUND)
+    )
+  )
+)
+
+;; Authorizes a user for specific actions.
+;; @param user: The principal to authorize.
+;; @returns (ok bool): True if authorization is successful.
+(define-public (authorize-user (user principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+    (asserts! (is-valid-principal user) (err ERR_INVALID_PRINCIPAL))
+    (ok (map-set UserAuthorization user true))
+  )
+)
+
+;; Revokes a user's authorization.
+;; @param user: The principal to revoke authorization from.
+;; @returns (ok bool): True if revocation is successful.
+(define-public (revoke-authorization (user principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT_OWNER) (err ERR_NOT_AUTHORIZED))
+    (asserts! (is-valid-principal user) (err ERR_INVALID_PRINCIPAL))
+    (ok (map-set UserAuthorization user false))
+  )
+)
+
+;; --- Contract Initialization ---
+;; Initializes the contract upon deployment.
+(begin
+  (map-set UserAuthorization CONTRACT_OWNER true)
+  (print "UserProfile contract initialized")
+  (ok true)
+)

package/ft-trait.clar

@@ -0,0 +1,24 @@
+(define-trait ft-trait
+  (
+    ;; Transfer from the caller to a new principal
+    (transfer (uint principal principal) (response bool uint))
+
+    ;; the human readable name of the token
+    (get-name () (response (string-ascii 32) uint))
+
+    ;; the ticker symbol, or empty if none
+    (get-symbol () (response (string-ascii 32) uint))
+
+    ;; the number of decimals used, e.g. 6 would mean 1_000_000 represents 1 token
+    (get-decimals () (response uint uint))
+
+    ;; the balance of the passed principal
+    (get-balance (principal) (response uint uint))
+
+    ;; the current total supply (which does not need to be a constant)
+    (get-total-supply () (response uint uint))
+
+    ;; an optional URI that represents metadata of this token
+    (get-token-uri () (response (optional (string-utf8 256)) uint))
+  )
+)

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "strade-stx-contracts",
-  "version": "1.0.0",
-  "description": "Clarity smart contracts for Strade marketplace - escrow, dispute resolution, and user profiles on Stacks",
-  "main": "index.js",
-  "license": "ISC"
+  "version": "1.0.1",
+  "description": "Clarity smart contracts for Strade marketplace",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Marvy247/Strade.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Marvy247/Strade/issues"
+  },
+  "homepage": "https://github.com/Marvy247/Strade"
 }

package/token.clar

@@ -0,0 +1,178 @@
+;; Strade Token (BST) Contract
+;; This contract defines the Strade Token (BST), a fungible token compliant with the SIP-010 standard.
+;; It includes functions for transferring, minting, and burning tokens, as well as managing token metadata.
+
+;; --- Token Properties ---
+(define-fungible-token bst u1000000000000)
+
+;; --- Constants ---
+;; Defines immutable values used throughout the contract for error handling and configuration.
+
+(define-constant CONTRACT_OWNER tx-sender) ;; Sets the contract deployer as the owner.
+(define-constant ERR_OWNER_ONLY (err u100)) ;; Error for actions restricted to the contract owner.
+(define-constant ERR_NOT_AUTHORIZED (err u101)) ;; Error for unauthorized actions.
+(define-constant ERR_INVALID_AMOUNT (err u102)) ;; Error for invalid token amounts.
+(define-constant ERR_INSUFFICIENT_BALANCE (err u103)) ;; Error when a user has an insufficient token balance.
+(define-constant ERR_INVALID_RECIPIENT (err u104)) ;; Error for invalid recipient addresses.
+(define-constant ERR_INVALID_URI (err u105)) ;; Error for invalid token URIs.
+(define-constant ERR_MAX_SUPPLY_REACHED (err u106)) ;; Error when the maximum token supply is reached.
+(define-constant ERR_CONTRACT_PAUSED (err u107)) ;; Error for actions attempted while the contract is paused.
+(define-constant MAX_SUPPLY u10000000000000) ;; The maximum total supply of the token.
+
+;; --- Variables ---
+;; Defines mutable variables for tracking the token's state and metadata.
+
+(define-data-var token-name (string-utf8 32) u"Strade Token") ;; The name of the token.
+(define-data-var token-symbol (string-utf8 10) u"BST") ;; The symbol of the token.
+(define-data-var token-decimals uint u6) ;; The number of decimal places for the token.
+(define-data-var token-uri (optional (string-utf8 256)) none) ;; The URI for the token's metadata.
+(define-data-var contract-paused bool false) ;; A flag to pause or unpause the contract.
+
+;; --- Helper Functions ---
+
+;; Checks if a principal is a valid recipient for token transfers.
+(define-private (is-valid-recipient (recipient principal))
+  (not (is-eq recipient (as-contract tx-sender))))
+
+;; Checks if the contract is currently paused.
+(define-private (is-contract-not-paused)
+  (not (var-get contract-paused)))
+
+;; --- SIP-010 Functions ---
+;; Standard functions for a fungible token.
+
+;; Transfers tokens from the sender to the recipient.
+(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
+    (begin
+        (asserts! (is-contract-not-paused) ERR_CONTRACT_PAUSED)
+        (asserts! (is-eq tx-sender sender) ERR_NOT_AUTHORIZED)
+        (asserts! (> amount u0) ERR_INVALID_AMOUNT)
+        (asserts! (<= amount (ft-get-balance bst sender)) ERR_INSUFFICIENT_BALANCE)
+        (asserts! (is-valid-recipient recipient) ERR_INVALID_RECIPIENT)
+        (try! (ft-transfer? bst amount sender recipient))
+        (print (merge 
+            {event: "token_transferred", amount: amount, sender: sender, recipient: recipient}
+            (match memo
+                some-memo {memo: (some some-memo)}
+                {memo: none}
+            )
+        ))
+        (ok true)
+    )
+)
+
+;; Gets the name of the token.
+(define-read-only (get-name)
+    (ok (var-get token-name))
+)
+
+;; Gets the symbol of the token.
+(define-read-only (get-symbol)
+    (ok (var-get token-symbol))
+)
+
+;; Gets the number of decimals for the token.
+(define-read-only (get-decimals)
+    (ok (var-get token-decimals))
+)
+
+;; Gets the balance of a given principal.
+(define-read-only (get-balance (who principal))
+    (ok (ft-get-balance bst who))
+)
+
+;; Gets the total supply of the token.
+(define-read-only (get-total-supply)
+    (ok (ft-get-supply bst))
+)
+
+;; Gets the token's metadata URI.
+(define-read-only (get-token-uri)
+    (ok (var-get token-uri))
+)
+
+;; --- Public Management Functions ---
+
+;; Mints new tokens and assigns them to a recipient.
+;; @param amount: The amount of tokens to mint.
+;; @param recipient: The principal to receive the new tokens.
+(define-public (mint (amount uint) (recipient principal))
+    (begin
+        (asserts! (is-contract-not-paused) ERR_CONTRACT_PAUSED)
+        (asserts! (is-eq tx-sender CONTRACT_OWNER) ERR_OWNER_ONLY)
+        (asserts! (> amount u0) ERR_INVALID_AMOUNT)
+        (asserts! (is-valid-recipient recipient) ERR_INVALID_RECIPIENT)
+        (asserts! (<= (+ amount (ft-get-supply bst)) MAX_SUPPLY) ERR_MAX_SUPPLY_REACHED)
+        (match (ft-mint? bst amount recipient)
+            success (begin
+                (print {event: "token_minted", amount: amount, recipient: recipient})
+                (ok success))
+            error (err error))
+    )
+)
+
+;; Burns a specified amount of tokens from the sender's balance.
+;; @param amount: The amount of tokens to burn.
+;; @param sender: The principal whose tokens will be burned.
+(define-public (burn (amount uint) (sender principal))
+    (begin
+        (asserts! (is-contract-not-paused) ERR_CONTRACT_PAUSED)
+        (asserts! (is-eq tx-sender sender) ERR_NOT_AUTHORIZED)
+        (asserts! (> amount u0) ERR_INVALID_AMOUNT)
+        (asserts! (<= amount (ft-get-balance bst sender)) ERR_INSUFFICIENT_BALANCE)
+        (match (ft-burn? bst amount sender)
+            success (begin
+                (print {event: "token_burned", amount: amount, sender: sender})
+                (ok success))
+            error (err error))
+    )
+)
+
+;; Sets the token's metadata URI.
+;; @param new-uri: The new URI for the token metadata.
+(define-public (set-token-uri (new-uri (optional (string-utf8 256))))
+    (begin
+        (asserts! (is-eq tx-sender CONTRACT_OWNER) ERR_OWNER_ONLY)
+        (match new-uri
+            some-uri 
+                (begin
+                    (asserts! (<= (len some-uri) u256) ERR_INVALID_URI)
+                    (var-set token-uri (some some-uri))
+                    (print {event: "token_uri_updated", new_uri: some-uri})
+                    (ok true)
+                )
+            (begin
+                (var-set token-uri none)
+                (print {event: "token_uri_removed"})
+                (ok true)
+            )
+        )
+    )
+)
+
+;; Pauses the contract, disabling most functions.
+(define-public (pause-contract)
+    (begin
+        (asserts! (is-eq tx-sender CONTRACT_OWNER) ERR_OWNER_ONLY)
+        (var-set contract-paused true)
+        (print {event: "contract_paused"})
+        (ok true)
+    )
+)
+
+;; Unpauses the contract, re-enabling all functions.
+(define-public (unpause-contract)
+    (begin
+        (asserts! (is-eq tx-sender CONTRACT_OWNER) ERR_OWNER_ONLY)
+        (var-set contract-paused false)
+        (print {event: "contract_unpaused"})
+        (ok true)
+    )
+)
+
+;; --- Contract Initialization ---
+;; Initializes the contract upon deployment, minting the initial supply to the contract owner.
+(begin
+    (try! (ft-mint? bst u1000000000000 CONTRACT_OWNER))
+    (print {event: "contract_deployed", initial_supply: u1000000000000})
+)

package/index.js

@@ -1 +0,0 @@
-module.exports = { name: "strade-stx-contracts", version: "1.0.0" };