LCOV - code coverage report
Current view: top level - contracts/extensions - bme010-0-token-sale.clar (source / functions) Coverage Total Hit
Test: lcov.info Lines: 95.7 % 93 89
Test Date: 2025-11-10 13:03:30 Functions: 90.9 % 11 10
Branches: 54.5 % 22 12

             Branch data     Line data    Source code
       1                 :             : ;; Title: BME010 Token Sale
       2                 :             : ;; Synopsis:
       3                 :             : ;; Enables token sale for govenernance tokens.
       4                 :             : ;; Description:
       5                 :             : ;; Allows to token sale over 6 stages with token price set at each stage by the current DAO.
       6                 :             : ;; Contract allows any stage to be cancelled and for tokens to be reclaimed.
       7                 :             : ;; Listing via a DEX is not supported but can be enabled at any stage
       8                 :             : ;; 
       9                 :             : 
      10                 :             : (impl-trait 'SP3JP0N1ZXGASRJ0F7QAHWFPGTVK9T2XNXDB908Z.extension-trait.extension-trait)
      11                 :             : 
      12                 :             : (define-constant err-unauthorised (err u5000))
      13                 :             : (define-constant err-invalid-stage (err u5001))
      14                 :             : (define-constant err-stage-sold-out (err u5002))
      15                 :             : (define-constant err-nothing-to-claim (err u5003))
      16                 :             : (define-constant err-no-more-stages (err u5005))
      17                 :             : (define-constant err-already-cancelled (err u5006))
      18                 :             : (define-constant err-no-purchase (err u5007))
      19                 :             : (define-constant err-stage-not-cancelled (err u5008))
      20                 :             : (define-constant err-stage-cancelled (err u5009))
      21                 :             : (define-constant err-user-limit-reached (err u5010))
      22                 :             : 
      23                 :             : (define-constant SCALE u1000000)
      24                 :             : (define-constant MICROSTX u1000000)
      25                 :             : 
      26                 :             : (define-data-var current-stage uint u1) ;; IDO starts at Stage 1
      27                 :             : (define-data-var current-stage-start uint burn-block-height) ;; Tracks burn-block-height when stage begins
      28                 :             : (define-data-var max-user-ido-purchase uint u500000000000)
      29                 :             : 
      30                 :             : (define-map ido-stage-details uint 
      31                 :             :   {price: uint, max-supply: uint, tokens-sold: uint, cancelled: bool})
      32                 :             : (define-map ido-purchases {stage: uint, buyer: principal} uint) ;; Tracks purchases
      33                 :             : 
      34                 :             : ;; --- Authorisation check
      35                 :             : 
      36                 :          14 : (define-public (is-dao-or-extension)
      37    [ + ][ +  + ]:          32 :         (ok (asserts! (or (is-eq tx-sender .bigmarket-dao) (contract-call? .bigmarket-dao is-extension contract-caller)) err-unauthorised))
      38                 :             : )
      39                 :             : 
      40                 :           1 : (define-public (set-max-user-ido-purchase (ido-purchase-limit uint))
      41                 :           1 :   (begin
      42                 :           1 :     (try! (is-dao-or-extension))
      43                 :           0 :     (var-set max-user-ido-purchase ido-purchase-limit)
      44                 :           0 :     (ok true)
      45                 :             :   )
      46                 :             : )
      47                 :             : 
      48                 :           2 : (define-read-only (get-ido-stages)
      49                 :           2 :   (list
      50                 :           2 :     (map-get? ido-stage-details u1)
      51                 :           2 :     (map-get? ido-stage-details u2)
      52                 :           2 :     (map-get? ido-stage-details u3)
      53                 :           2 :     (map-get? ido-stage-details u4)
      54                 :           2 :     (map-get? ido-stage-details u5)
      55                 :           2 :     (map-get? ido-stage-details u6)
      56                 :             :   )
      57                 :             : )
      58                 :             : 
      59                 :           1 : (define-read-only (get-ido-user-for-stage (stage uint) (who principal))
      60                 :           1 :   (map-get? ido-purchases {stage: stage, buyer: who})
      61                 :             : )
      62                 :             : 
      63                 :           1 : (define-read-only (get-ido-user (who principal))
      64                 :           1 :   (list 
      65         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u1, buyer: who}) value value u0 )
      66         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u2, buyer: who}) value value u0 )
      67         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u3, buyer: who}) value value u0 )
      68         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u4, buyer: who}) value value u0 )
      69         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u5, buyer: who}) value value u0 )
      70         [ -  + ]:           1 :     (match (map-get? ido-purchases {stage: u6, buyer: who}) value value u0 )
      71                 :             :   )
      72                 :             : )
      73                 :             : 
      74                 :             : ;; --- Internal DAO functions
      75                 :             : 
      76                 :          14 : (define-public (initialize-ido)
      77                 :          14 :   (begin
      78                 :          14 :     (try! (is-dao-or-extension))
      79                 :             : 
      80                 :             :     ;; Set up each stage
      81                 :          12 :   (map-set ido-stage-details u1 {price: (* u5 SCALE),  max-supply: u6000000000000, tokens-sold: u0, cancelled: false})
      82                 :          12 :   (map-set ido-stage-details u2 {price: (* u6 SCALE),  max-supply: u8333330000000, tokens-sold: u0, cancelled: false})
      83                 :          12 :   (map-set ido-stage-details u3 {price: (* u7 SCALE),  max-supply: u10714290000000, tokens-sold: u0, cancelled: false})
      84                 :          12 :   (map-set ido-stage-details u4 {price: (* u8 SCALE),  max-supply: u12500000000000, tokens-sold: u0, cancelled: false})
      85                 :          12 :   (map-set ido-stage-details u5 {price: (* u10 SCALE), max-supply: u15000000000000, tokens-sold: u0, cancelled: false})
      86                 :          12 :   (map-set ido-stage-details u6 {price: (* u20 SCALE), max-supply: u10000000000000, tokens-sold: u0, cancelled: false})
      87                 :             : 
      88                 :          12 :     (print {event: "ido-initialized"})
      89                 :          12 :     (ok true)
      90                 :             :   )
      91                 :             : )
      92                 :             : 
      93                 :           5 : (define-public (buy-ido-tokens (stx-amount uint))
      94                 :          12 :   (let (
      95                 :          12 :     (stage (var-get current-stage))
      96                 :          12 :     (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
      97                 :          11 :     (bmg-price (get price stage-info))
      98                 :          11 :     (max-supply (get max-supply stage-info))
      99                 :          11 :     (tokens-sold (get tokens-sold stage-info))
     100                 :          11 :     (sender tx-sender)
     101                 :          11 :                 (cancelled (get cancelled stage-info))
     102                 :          11 :     (current-stake (default-to u0 (map-get? ido-purchases {stage: stage, buyer: tx-sender})))
     103                 :          11 :     (stx-in-stx (/ (* stx-amount SCALE) MICROSTX))
     104                 :          11 :     (tokens-to-buy (/ (* stx-in-stx bmg-price) SCALE))
     105                 :             : 
     106                 :             :         )
     107                 :             :     ;; assert account limit not reached
     108            [ + ]:          11 :     (asserts! (<= (+ current-stake tokens-to-buy) (var-get max-user-ido-purchase)) err-user-limit-reached)
     109                 :             :     ;; Ensure enough supply remains
     110            [ - ]:          10 :     (asserts! (<= (+ tokens-sold tokens-to-buy) max-supply) err-stage-sold-out)
     111            [ + ]:          10 :     (asserts! (not cancelled) err-stage-cancelled)
     112                 :             : 
     113                 :             :     ;; Accept STX payment
     114                 :           9 :     (try! (stx-transfer? stx-amount tx-sender .bme006-0-treasury))
     115                 :             : 
     116                 :             :     ;; Mint tokens directly to the buyer
     117                 :           9 :     (try! (as-contract (contract-call? .bme000-0-governance-token bmg-mint tokens-to-buy sender)))
     118                 :             : 
     119                 :             :     ;; Update stage details
     120                 :           9 :     (map-set ido-stage-details stage (merge stage-info {tokens-sold: (+ tokens-sold tokens-to-buy)}))
     121                 :           9 :     (map-set ido-purchases {stage: stage, buyer: tx-sender} (+ current-stake tokens-to-buy))
     122                 :             : 
     123                 :           9 :     (print {event: "ido-purchase", buyer: tx-sender, stage: stage, tokens: tokens-to-buy, stx-amount: stx-amount})
     124                 :             : 
     125                 :           9 :     (ok tokens-to-buy)
     126                 :             :   )
     127                 :             : )
     128                 :             : 
     129                 :           4 : (define-public (advance-ido-stage)
     130                 :          14 :   (begin
     131                 :          14 :     (try! (is-dao-or-extension))
     132                 :          11 :     (let (
     133                 :          11 :       (stage (var-get current-stage))
     134                 :          11 :       (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
     135                 :             :     )
     136                 :             :       
     137            [ - ]:          11 :     (asserts! (not (get cancelled stage-info)) err-already-cancelled) ;; Ensure not already cancelled
     138            [ + ]:          11 :     (asserts! (< stage u6) err-no-more-stages) ;; Can't go past stage 6
     139                 :          10 :     (var-set current-stage (+ u1 stage)) ;; Move to the next stage
     140                 :             : 
     141                 :             :     ;; Use burn-block-height to track when the stage starts
     142                 :          10 :     (var-set current-stage-start burn-block-height)
     143                 :             : 
     144                 :          10 :     (print {event: "ido-stage-advanced", new-stage: (var-get current-stage), burn-start: burn-block-height})
     145                 :          10 :     (ok stage)
     146                 :             :     )
     147                 :             : 
     148                 :             :   )
     149                 :             : )
     150                 :             : 
     151                 :           3 : (define-public (cancel-ido-stage)
     152                 :           3 :   (begin
     153                 :           3 :     (try! (is-dao-or-extension))
     154                 :             : 
     155                 :           2 :     (let ((stage (var-get current-stage))
     156                 :           2 :           (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage)))
     157                 :             :       
     158            [ - ]:           2 :       (asserts! (not (get cancelled stage-info)) err-already-cancelled) ;; Ensure not already cancelled
     159                 :             :       
     160                 :             :       ;; Update the stage's cancelled flag
     161                 :           2 :       (map-set ido-stage-details stage (merge stage-info {cancelled: true}))
     162                 :             : 
     163                 :           2 :       (print {event: "cancel-ido-stage", stage: stage})
     164                 :           2 :       (ok true)
     165                 :             :     )
     166                 :             :   )
     167                 :             : )
     168                 :             : 
     169                 :           2 : (define-public (claim-ido-refund)
     170                 :           3 :   (let ((stage (var-get current-stage))
     171                 :           3 :         (purchase-amount (unwrap! (map-get? ido-purchases {stage: stage, buyer: tx-sender}) err-no-purchase))
     172                 :           2 :         (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
     173                 :           2 :         (price (get price stage-info))
     174                 :           2 :         (sender tx-sender)
     175                 :           2 :         (refund (/ (* purchase-amount price) SCALE))
     176                 :             :         )
     177                 :             :     ;; Ensure stage is actually cancelled
     178            [ - ]:           2 :     (asserts! (get cancelled stage-info) err-stage-not-cancelled)
     179                 :             :     ;; Transfer STX back to the buyer / burn the bdg
     180                 :           2 :     (try! (as-contract (contract-call? .bme006-0-treasury stx-transfer refund sender none)))
     181                 :           1 :     (try! (as-contract (contract-call? .bme000-0-governance-token bmg-burn purchase-amount sender)))
     182                 :             :     ;; Remove the purchase record
     183                 :           1 :     (map-delete ido-purchases {stage: stage, buyer: tx-sender})
     184                 :           1 :     (print {event: "ido-refund", buyer: tx-sender, refunded: purchase-amount, stage: stage})
     185                 :           1 :     (ok purchase-amount)
     186                 :             :   )
     187                 :             : )
     188                 :             : 
     189                 :             : ;; --- Extension callback
     190                 :             : 
     191                 :           0 : (define-public (callback (sender principal) (memo (buff 34)))
     192                 :           0 :         (ok true)
     193                 :             : )
        

Generated by: LCOV version 2.3.2-1