LCOV - code coverage report
Current view: top level - contracts/extensions - bme010-0-token-sale.clar (source / functions) Coverage Total Hit
Test: lcov.info Lines: 73.9 % 92 68
Test Date: 2025-11-05 13:50:37 Functions: 54.5 % 11 6
Branches: 30.0 % 20 6

             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                 :          10 : (define-public (is-dao-or-extension)
      37    [ + ][ +  + ]:          25 :         (ok (asserts! (or (is-eq tx-sender .bigmarket-dao) (contract-call? .bigmarket-dao is-extension contract-caller)) err-unauthorised))
      38                 :             : )
      39                 :             : 
      40                 :           0 : (define-public (set-max-user-ido-purchase (ido-purchase-limit uint))
      41                 :           0 :   (begin
      42                 :           0 :     (try! (is-dao-or-extension))
      43                 :           0 :     (var-set max-user-ido-purchase ido-purchase-limit)
      44                 :           0 :     (ok true)
      45                 :             :   )
      46                 :             : )
      47                 :             : 
      48                 :           0 : (define-read-only (get-ido-stages)
      49                 :           0 :   (list
      50                 :           0 :     (map-get? ido-stage-details u1)
      51                 :           0 :     (map-get? ido-stage-details u2)
      52                 :           0 :     (map-get? ido-stage-details u3)
      53                 :           0 :     (map-get? ido-stage-details u4)
      54                 :           0 :     (map-get? ido-stage-details u5)
      55                 :           0 :     (map-get? ido-stage-details u6)
      56                 :             :   )
      57                 :             : )
      58                 :             : 
      59                 :           0 : (define-read-only (get-ido-user-for-stage (stage uint) (who principal))
      60                 :           0 :   (map-get? ido-purchases {stage: stage, buyer: who})
      61                 :             : )
      62                 :             : 
      63                 :           0 : (define-read-only (get-ido-user (who principal))
      64                 :           0 :   (list 
      65         [ -  - ]:           0 :     (match (map-get? ido-purchases {stage: u1, buyer: who}) value value u0 )
      66         [ -  - ]:           0 :     (match (map-get? ido-purchases {stage: u2, buyer: who}) value value u0 )
      67         [ -  - ]:           0 :     (match (map-get? ido-purchases {stage: u3, buyer: who}) value value u0 )
      68         [ -  - ]:           0 :     (match (map-get? ido-purchases {stage: u4, buyer: who}) value value u0 )
      69         [ -  - ]:           0 :     (match (map-get? ido-purchases {stage: u5, buyer: who}) value value u0 )
      70                 :             :   )
      71                 :             : )
      72                 :             : 
      73                 :             : ;; --- Internal DAO functions
      74                 :             : 
      75                 :          10 : (define-public (initialize-ido)
      76                 :          10 :   (begin
      77                 :          10 :     (try! (is-dao-or-extension))
      78                 :             : 
      79                 :             :     ;; Set up each stage
      80                 :           9 :   (map-set ido-stage-details u1 {price: (* u5 SCALE),  max-supply: u6000000000000, tokens-sold: u0, cancelled: false})
      81                 :           9 :   (map-set ido-stage-details u2 {price: (* u6 SCALE),  max-supply: u8333330000000, tokens-sold: u0, cancelled: false})
      82                 :           9 :   (map-set ido-stage-details u3 {price: (* u7 SCALE),  max-supply: u10714290000000, tokens-sold: u0, cancelled: false})
      83                 :           9 :   (map-set ido-stage-details u4 {price: (* u8 SCALE),  max-supply: u12500000000000, tokens-sold: u0, cancelled: false})
      84                 :           9 :   (map-set ido-stage-details u5 {price: (* u10 SCALE), max-supply: u15000000000000, tokens-sold: u0, cancelled: false})
      85                 :           9 :   (map-set ido-stage-details u6 {price: (* u20 SCALE), max-supply: u10000000000000, tokens-sold: u0, cancelled: false})
      86                 :             : 
      87                 :           9 :     (print {event: "ido-initialized"})
      88                 :           9 :     (ok true)
      89                 :             :   )
      90                 :             : )
      91                 :             : 
      92                 :           5 : (define-public (buy-ido-tokens (stx-amount uint))
      93                 :          12 :   (let (
      94                 :          12 :     (stage (var-get current-stage))
      95                 :          12 :     (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
      96                 :          11 :     (bmg-price (get price stage-info))
      97                 :          11 :     (max-supply (get max-supply stage-info))
      98                 :          11 :     (tokens-sold (get tokens-sold stage-info))
      99                 :          11 :     (sender tx-sender)
     100                 :          11 :                 (cancelled (get cancelled stage-info))
     101                 :          11 :     (current-stake (default-to u0 (map-get? ido-purchases {stage: stage, buyer: tx-sender})))
     102                 :          11 :     (stx-in-stx (/ (* stx-amount SCALE) MICROSTX))
     103                 :          11 :     (tokens-to-buy (/ (* stx-in-stx bmg-price) SCALE))
     104                 :             : 
     105                 :             :         )
     106                 :             :     ;; assert account limit not reached
     107            [ + ]:          11 :     (asserts! (<= (+ current-stake tokens-to-buy) (var-get max-user-ido-purchase)) err-user-limit-reached)
     108                 :             :     ;; Ensure enough supply remains
     109            [ - ]:          10 :     (asserts! (<= (+ tokens-sold tokens-to-buy) max-supply) err-stage-sold-out)
     110            [ + ]:          10 :     (asserts! (not cancelled) err-stage-cancelled)
     111                 :             : 
     112                 :             :     ;; Accept STX payment
     113                 :           9 :     (try! (stx-transfer? stx-amount tx-sender .bme006-0-treasury))
     114                 :             : 
     115                 :             :     ;; Mint tokens directly to the buyer
     116                 :           9 :     (try! (as-contract (contract-call? .bme000-0-governance-token bmg-mint tokens-to-buy sender)))
     117                 :             : 
     118                 :             :     ;; Update stage details
     119                 :           9 :     (map-set ido-stage-details stage (merge stage-info {tokens-sold: (+ tokens-sold tokens-to-buy)}))
     120                 :           9 :     (map-set ido-purchases {stage: stage, buyer: tx-sender} (+ current-stake tokens-to-buy))
     121                 :             : 
     122                 :           9 :     (print {event: "ido-purchase", buyer: tx-sender, stage: stage, tokens: tokens-to-buy, stx-amount: stx-amount})
     123                 :             : 
     124                 :           9 :     (ok tokens-to-buy)
     125                 :             :   )
     126                 :             : )
     127                 :             : 
     128                 :           3 : (define-public (advance-ido-stage)
     129                 :          13 :   (begin
     130                 :          13 :     (try! (is-dao-or-extension))
     131                 :          11 :     (let (
     132                 :          11 :       (stage (var-get current-stage))
     133                 :          11 :       (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
     134                 :             :     )
     135                 :             :       
     136            [ - ]:          11 :     (asserts! (not (get cancelled stage-info)) err-already-cancelled) ;; Ensure not already cancelled
     137            [ + ]:          11 :     (asserts! (< stage u6) err-no-more-stages) ;; Can't go past stage 6
     138                 :          10 :     (var-set current-stage (+ u1 stage)) ;; Move to the next stage
     139                 :             : 
     140                 :             :     ;; Use burn-block-height to track when the stage starts
     141                 :          10 :     (var-set current-stage-start burn-block-height)
     142                 :             : 
     143                 :          10 :     (print {event: "ido-stage-advanced", new-stage: (var-get current-stage), burn-start: burn-block-height})
     144                 :          10 :     (ok stage)
     145                 :             :     )
     146                 :             : 
     147                 :             :   )
     148                 :             : )
     149                 :             : 
     150                 :           2 : (define-public (cancel-ido-stage)
     151                 :           2 :   (begin
     152                 :           2 :     (try! (is-dao-or-extension))
     153                 :             : 
     154                 :           2 :     (let ((stage (var-get current-stage))
     155                 :           2 :           (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage)))
     156                 :             :       
     157            [ - ]:           2 :       (asserts! (not (get cancelled stage-info)) err-already-cancelled) ;; Ensure not already cancelled
     158                 :             :       
     159                 :             :       ;; Update the stage's cancelled flag
     160                 :           2 :       (map-set ido-stage-details stage (merge stage-info {cancelled: true}))
     161                 :             : 
     162                 :           2 :       (print {event: "cancel-ido-stage", stage: stage})
     163                 :           2 :       (ok true)
     164                 :             :     )
     165                 :             :   )
     166                 :             : )
     167                 :             : 
     168                 :           2 : (define-public (claim-ido-refund)
     169                 :           3 :   (let ((stage (var-get current-stage))
     170                 :           3 :         (purchase-amount (unwrap! (map-get? ido-purchases {stage: stage, buyer: tx-sender}) err-no-purchase))
     171                 :           2 :         (stage-info (unwrap! (map-get? ido-stage-details stage) err-invalid-stage))
     172                 :           2 :         (price (get price stage-info))
     173                 :           2 :         (sender tx-sender)
     174                 :           2 :         (refund (/ (* purchase-amount price) SCALE))
     175                 :             :         )
     176                 :             :     ;; Ensure stage is actually cancelled
     177            [ - ]:           2 :     (asserts! (get cancelled stage-info) err-stage-not-cancelled)
     178                 :             :     ;; Transfer STX back to the buyer / burn the bdg
     179                 :           2 :     (try! (as-contract (contract-call? .bme006-0-treasury stx-transfer refund sender none)))
     180                 :           1 :     (try! (as-contract (contract-call? .bme000-0-governance-token bmg-burn purchase-amount sender)))
     181                 :             :     ;; Remove the purchase record
     182                 :           1 :     (map-delete ido-purchases {stage: stage, buyer: tx-sender})
     183                 :           1 :     (print {event: "ido-refund", buyer: tx-sender, refunded: purchase-amount, stage: stage})
     184                 :           1 :     (ok purchase-amount)
     185                 :             :   )
     186                 :             : )
     187                 :             : 
     188                 :             : ;; --- Extension callback
     189                 :             : 
     190                 :           0 : (define-public (callback (sender principal) (memo (buff 34)))
     191                 :           0 :         (ok true)
     192                 :             : )
        

Generated by: LCOV version 2.3.2-1