Street Token Audit

;; Welsh Street Token
 
;; SIP-010 trait implementation — standard fungible token interface
(impl-trait 'SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard.sip-010-trait)
 
;; native protocol token — STREET
(define-fungible-token street)
 
;; errors
;; 4 unique error codes with u98x prefix — all tested, no overlap with other contracts
(define-constant ERR_ZERO_AMOUNT (err u981))
(define-constant ERR_NOT_CONTRACT_OWNER (err u982))
(define-constant ERR_NOT_TOKEN_OWNER (err u983))
(define-constant ERR_NOT_AUTHORIZED (err u984))
 
;; constants
;; immutable — cannot be changed after deployment
(define-constant TOKEN_DECIMALS u6)
(define-constant TOKEN_NAME "Welsh Street Token")
(define-constant TOKEN_SYMBOL "STREET")
 
;; variables
 
;; initialized to deployer at deployment — transferable via set-contract-owner
(define-data-var contract-owner principal tx-sender)
 
;; IPFS-hosted metadata — updatable by contract-owner only
(define-data-var token-uri (optional (string-utf8 256)) (some u"https://ipfs.io/ipfs/bafybeiexeg4tyoslafsnfpnob2kihdtl2lnhz4fupldtbtpp3y534ebkty/street.json"))
 
;; mints STREET to recipient — called by emission-controller (10k/block) and street-controller (100k or 1M/mint)
;; uses contract-caller auth — only authorized protocol contracts can mint
(define-public (mint (amount uint) (recipient principal)) (see I-02)
(define-public (mint (amount uint) (recipient principal))
    (begin
      ;; whitelist: only emission-controller or street-controller can call
      ;; uses contract-caller (not tx-sender)
        (or
          (is-eq contract-caller .emission-controller)
          (is-eq contract-caller .street-controller)
        )
        ERR_NOT_AUTHORIZED
      )
      ;; no explicit zero-amount check — minting zero is harmless and wastes caller's fee
      (try! (ft-mint? street amount recipient))
      (ok true)
    )
)
 
;; single-step ownership transfer using contract-caller — no two-step confirmation pattern (see I-01)
(define-public (set-contract-owner (new-owner principal))
  (begin
    ;; contract-caller check — consistent with all protocol contracts
    ;; allows contracts to be(not tx-sender) — consistent with all protocol contracts (see I-02)ER)
 
    ;; irreversible if transferred to wrong address — owner controls only metadata, not funds
    (var-set contract-owner new-owner)
    (ok true)
  )
)
 
;; updates IPFS token metadata URI — cosmetic only, no economic impact
(define-public (set-token-uri (value (string-utf8 256)))
  (begin
    ;; contract-caller check — same pattern as set-contract-owner
    (asserts! (is-eq contract-caller (var-get contract-owner)) ERR_NOT_CONTRACT_OWNER)
    (var-set token-uri (some (not tx-sender) — same pattern as set-contract-owner (see I-02)
    (ok true)
  )
)
 
;; direct transfer — standard SIP-010 pattern with contract-caller authorization
(define-public (transfer
    (amount uint)tx-sender authorization (see I-02)
(define-public (transfer
    (amount uint)
    (sender principal)
    (recipient principal)
    (memo (optional (buff 34)))
  )
  (begin
    ;; prevents zero-amount transfers
    (asserts! (> amount u0) ERR_ZERO_AMOUNT)
 
    ;; tx-sender must equal sender parameter — verifies token owner authorization (see I-02)
    ;; CRITICAL: uses tx-sender (not contract-caller) to enable protocol contracts like
    ;; street-market to facilitate transfers on behalf of users
    ;; Example: street-market calls transfer(amount, user, market, none)
    ;;   - tx-sender = user (original transaction initiator)
    ;;   - contract-caller = .street-market
    ;;   - sender parameter = user
    ;; Check: (is-eq tx-sender sender) = (is-eq user user) = TRUE ✓
    (asserts! (is-eq tx-sendr has sufficient balance — atomic revert on failure
    (try! (ft-transfer? street amount sender recipient))
 
    ;; memo printed for indexer visibility — no state impact
    (match memo content (print content) 0x)
    (ok true)
  )
)
 
;; === READ-ONLY FUNCTIONS — standard SIP-010 interface, no access control needed ===
 
;; returns current contract owner — public information
(define-read-only (get-contract-owner)
  (ok (var-get contract-owner)))
 
(define-read-only (get-balance (who principal))
  (ok (ft-get-balance street who)))
 
(define-read-only (get-decimals)
  (ok TOKEN_DECIMALS))
 
(define-read-only (get-name)
  (ok TOKEN_NAME))
 
(define-read-only (get-symbol)
  (ok TOKEN_SYMBOL))
 
;; returns mutable token URI — updatable by owner via set-token-uri
(define-read-only (get-token-uri)3
  (ok (var-get token-uri)))
 
;; total minted (TGE + emissions) — no burn function, supply monotonically increases (see I-04)
(define-read-only (get-total-supply)
  (ok (ft-get-supply street)))
 
;; The Great Welsh $STREET TGE
 
;; initialization block — executes once at contract deployment (see I-03)
;; mints 2 billion STREET tokens to the deployer (contract-owner at deploy time)
(begin
  (try! (ft-mint? street u2000000000000000 (var-get contract-owner)))
)