Functions reference

(+ i1 i2...)

(+ 1 2 3) ;; Returns 6
(+ u10 u20) ;; Returns u30

;; Counter example
(define-data-var counter int 0)
(define-public (increment (amount int))
  (begin
    (var-set counter (+ (var-get counter) amount))
    (ok (var-get counter))))

(- i1 i2...)

(- 10 3) ;; Returns 7
(- 100 20 10) ;; Returns 70
(- u50 u30) ;; Returns u20

;; Decrease balance
(define-public (withdraw (amount uint))
  (let ((balance (var-get user-balance)))
    (asserts! (>= balance amount) (err u1))
    (var-set user-balance (- balance amount))
    (ok amount)))

(* i1 i2...)

(* 3 4) ;; Returns 12
(* 2 3 4) ;; Returns 24
(* u5 u10) ;; Returns u50

;; Calculate percentage
(define-read-only (calculate-fee (amount uint))
  (/ (* amount u3) u100)) ;; 3% fee

(/ i1 i2...)

(/ 10 2) ;; Returns 5
(/ 100 10 2) ;; Returns 5
(/ u60 u3) ;; Returns u20

;; Calculate average
(define-read-only (average (a uint) (b uint))
  (/ (+ a b) u2))

(mod i1 i2)

(mod 10 3) ;; Returns 1
(mod u17 u5) ;; Returns u2

;; Check if even
(define-read-only (is-even (n uint))
  (is-eq (mod n u2) u0))

(pow i1 i2)

(pow 2 3) ;; Returns 8
(pow u10 u2) ;; Returns u100

;; Calculate compound interest
(define-read-only (compound-interest (principal uint) (rate uint) (periods uint))
  (let ((rate-factor (+ u100 rate)))
    (/ (* principal (pow rate-factor periods)) (pow u100 periods))))

(sqrti n)

(sqrti u16) ;; Returns u4
(sqrti u100) ;; Returns u10
(sqrti 25) ;; Returns 5

;; Calculate distance (simplified)
(define-read-only (distance (x uint) (y uint))
  (sqrti (+ (* x x) (* y y))))

(log2 n)

(log2 u8) ;; Returns u3
(log2 u256) ;; Returns u8

;; Calculate bit position
(define-read-only (highest-bit-position (n uint))
  (if (> n u0)
    (some (log2 n))
    none))

(< i1 i2)

(< 5 10) ;; Returns true
(< u100 u50) ;; Returns false

;; Validate minimum
(define-public (deposit (amount uint))
  (begin
    (asserts! (< u0 amount) (err u1))
    (ok amount)))

(> i1 i2)

(> 10 5) ;; Returns true
(> u50 u100) ;; Returns false

;; Check maximum
(define-read-only (exceeds-limit (value uint))
  (> value u1000000))

(<= i1 i2)

(<= 5 10) ;; Returns true
(<= 10 10) ;; Returns true
(<= u100 u50) ;; Returns false

;; Validate range
(define-read-only (is-valid-percentage (value uint))
  (and (<= u0 value) (<= value u100)))

(>= i1 i2)

(>= 10 5) ;; Returns true
(>= 10 10) ;; Returns true
(>= u50 u100) ;; Returns false

;; Check balance
(define-public (can-afford (price uint))
  (ok (>= (stx-get-balance tx-sender) price)))

(and b1 b2...)

(and true true) ;; Returns true
(and true false) ;; Returns false
(and true true true) ;; Returns true

;; Multiple conditions
(define-read-only (is-valid-transfer (amount uint) (recipient principal))
  (and 
    (> amount u0)
    (not (is-eq recipient tx-sender))
    (<= amount (get-balance tx-sender))))

(or b1 b2...)

(or true false) ;; Returns true
(or false false) ;; Returns false
(or false false true) ;; Returns true

;; Check permissions
(define-read-only (can-access (user principal))
  (or 
    (is-eq user contract-owner)
    (default-to false (map-get? admins user))
    (var-get public-access)))

(not b)

(not true) ;; Returns false
(not false) ;; Returns true

;; Check if not owner
(define-read-only (is-not-owner (user principal))
  (not (is-eq user contract-owner)))

(xor b1 b2)

(xor true false) ;; Returns true
(xor true true) ;; Returns false
(xor false false) ;; Returns false

;; Exclusive access
(define-read-only (has-exclusive-role (is-admin bool) (is-moderator bool))
  (xor is-admin is-moderator))

(is-eq v1 v2...)

(is-eq 5 5) ;; Returns true
(is-eq "hello" "hello") ;; Returns true
(is-eq u10 u20) ;; Returns false
(is-eq 1 1 1) ;; Returns true

;; Check owner
(define-public (admin-only)
  (begin
    (asserts! (is-eq tx-sender contract-owner) (err u401))
    (ok true)))

(list v1 v2...)

(list 1 2 3) ;; Returns (1 2 3)
(list true false true) ;; Returns (true false true)

;; Create address list
(define-data-var admins (list 5 principal) 
  (list 'SP1234... 'SP5678...))

(append list-expr element)

(append (list 1 2) 3) ;; Returns (1 2 3)
(append (list) u10) ;; Returns (u10)

;; Add to list
(define-public (add-member (member principal))
  (let ((current-list (var-get members)))
    (match (as-max-len? (append current-list member) u100)
      new-list (begin
        (var-set members new-list)
        (ok true))
      (err u1))))

(concat sequence1 sequence2)

(concat "Hello " "World") ;; Returns "Hello World"
(concat 0x0102 0x0304) ;; Returns 0x01020304
(concat (list 1 2) (list 3 4)) ;; Returns (1 2 3 4)

;; Combine strings
(define-read-only (format-message (prefix (string-ascii 10)) (msg (string-ascii 50)))
  (concat prefix msg))

(len sequence)

(len "Hello") ;; Returns u5
(len (list 1 2 3)) ;; Returns u3
(len 0x0102) ;; Returns u2

;; Validate length
(define-public (set-name (name (string-ascii 50)))
  (begin
    (asserts! (> (len name) u0) (err u1))
    (asserts! (<= (len name) u20) (err u2))
    (ok name)))

(element-at sequence index)

(element-at "Hello" u1) ;; Returns (some "e")
(element-at (list 10 20 30) u2) ;; Returns (some 30)
(element-at (list 1 2) u5) ;; Returns none

;; Get from list safely
(define-read-only (get-member-at (index uint))
  (element-at (var-get members) index))

(index-of sequence element)

(index-of "Hello" "l") ;; Returns (some u2)
(index-of (list 1 2 3 2) 2) ;; Returns (some u1)
(index-of (list 1 2 3) 5) ;; Returns none

;; Check membership
(define-read-only (is-member (user principal))
  (is-some (index-of (var-get members) user)))

(slice sequence left-position right-position)

(slice "Hello World" u0 u5) ;; Returns (some "Hello")
(slice (list 1 2 3 4 5) u1 u4) ;; Returns (some (2 3 4))

;; Extract substring
(define-read-only (get-prefix (text (string-ascii 100)) (length uint))
  (slice text u0 length))

(replace-at sequence index new-element)

(replace-at "Hello" u1 "a") ;; Returns (some "Hallo")
(replace-at (list 1 2 3) u1 5) ;; Returns (some (1 5 3))

;; Update list element
(define-public (update-member (index uint) (new-member principal))
  (match (replace-at (var-get members) index new-member)
    new-list (begin
      (var-set members new-list)
      (ok true))
    (err u404)))

(map func list1 list2...)

(map + (list 1 2 3) (list 10 20 30)) ;; Returns (11 22 33)

;; Double all values
(define-private (double (x uint))
  (* x u2))

(define-read-only (double-all (numbers (list 10 uint)))
  (map double numbers))

(filter func list)

(define-private (is-even (x uint))
  (is-eq (mod x u2) u0))

(filter is-even (list u1 u2 u3 u4)) ;; Returns (u2 u4)

;; Filter active users
(define-read-only (get-active-users)
  (filter is-active (var-get all-users)))

(fold func list initial-value)

(fold + (list u1 u2 u3 u4) u0) ;; Returns u10

;; Sum balances
(define-private (add-balance (user principal) (total uint))
  (+ total (default-to u0 (map-get? balances user))))

(define-read-only (get-total-balance)
  (fold add-balance (var-get users) u0))

(int-to-ascii value)

(int-to-ascii 123) ;; Returns "123"
(int-to-ascii u456) ;; Returns "456"

;; Format ID
(define-read-only (format-id (id uint))
  (concat "ID-" (int-to-ascii id)))

(int-to-utf8 value)

(int-to-utf8 789) ;; Returns u"789"
(int-to-utf8 u100) ;; Returns u"100"

;; Create UTF-8 label
(define-read-only (create-label (num uint))
  (concat u"Label #" (int-to-utf8 num)))

(string-to-int string)

(string-to-int "123") ;; Returns (some 123)
(string-to-int "-456") ;; Returns (some -456)
(string-to-int "abc") ;; Returns none

;; Parse user input
(define-public (set-value (input (string-ascii 10)))
  (match (string-to-int input)
    value (ok (var-set stored-value value))
    (err u1)))

(string-to-uint string)

(string-to-uint "123") ;; Returns (some u123)
(string-to-uint "0") ;; Returns (some u0)
(string-to-uint "-123") ;; Returns none

;; Parse amount
(define-read-only (parse-amount (input (string-ascii 20)))
  (string-to-uint input))

(buff-to-int-be buffer)

(buff-to-int-be 0x0001) ;; Returns 1
(buff-to-int-be 0x00ff) ;; Returns 255
(buff-to-int-be 0xffff) ;; Returns -1

;; Parse signed data
(define-read-only (parse-signed-data (data (buff 8)))
  (buff-to-int-be data))

(buff-to-int-le buffer)

(buff-to-int-le 0x0100) ;; Returns 1
(buff-to-int-le 0xff00) ;; Returns 255

;; Parse little-endian data
(define-read-only (parse-le-data (data (buff 4)))
  (buff-to-int-le data))

(buff-to-uint-be buffer)

(buff-to-uint-be 0x0001) ;; Returns u1
(buff-to-uint-be 0x0100) ;; Returns u256

;; Parse network data
(define-read-only (parse-network-uint (data (buff 8)))
  (buff-to-uint-be data))

(buff-to-uint-le buffer)

(buff-to-uint-le 0x0100) ;; Returns u1
(buff-to-uint-le 0x0001) ;; Returns u256

;; Parse file data
(define-read-only (parse-file-size (data (buff 4)))
  (buff-to-uint-le data))

(define-constant name value)

(define-constant contract-owner tx-sender)
(define-constant token-name "MyToken")
(define-constant max-supply u1000000)

;; Use in functions
(define-read-only (get-owner)
  contract-owner)

(define-data-var name type value)

(define-data-var counter uint u0)
(define-data-var is-paused bool false)
(define-data-var admin principal tx-sender)

;; Update variable
(define-public (increment)
  (begin
    (var-set counter (+ (var-get counter) u1))
    (ok (var-get counter))))

(var-get name)

(define-data-var balance uint u100)

(define-read-only (get-balance)
  (var-get balance))

;; Use in calculations
(define-public (double-balance)
  (let ((current (var-get balance)))
    (var-set balance (* current u2))
    (ok (var-get balance))))

(var-set name value)

(define-data-var counter uint u0)

(define-public (set-counter (value uint))
  (begin
    (var-set counter value)
    (ok true)))

;; Conditional update
(define-public (update-if-higher (value uint))
  (if (> value (var-get counter))
    (begin
      (var-set counter value)
      (ok true))
    (err u1)))

(define-map name key-type value-type)

(define-map balances principal uint)
(define-map user-profiles 
  principal 
  {
    name: (string-ascii 50),
    age: uint,
    active: bool
  })

;; Composite key
(define-map allowances 
  { owner: principal, spender: principal } 
  uint)

(map-get? map-name key)

(define-map balances principal uint)

(define-read-only (get-balance (user principal))
  (default-to u0 (map-get? balances user)))

;; Pattern matching
(define-read-only (get-profile-name (user principal))
  (match (map-get? user-profiles user)
    profile (get name profile)
    "Unknown"))

(map-set map-name key value)

(define-map balances principal uint)

(define-public (set-balance (user principal) (amount uint))
  (begin
    (map-set balances user amount)
    (ok true)))

;; Update profile
(define-public (update-profile (name (string-ascii 50)) (age uint))
  (begin
    (map-set user-profiles tx-sender {
      name: name,
      age: age,
      active: true
    })
    (ok true)))

(map-insert map-name key value)

(define-map users principal { joined: uint })

(define-public (register)
  (if (map-insert users tx-sender { joined: block-height })
    (ok "Registered successfully")
    (err u409))) ;; Already exists

;; One-time initialization
(define-public (initialize-user (user principal))
  (begin
    (asserts! (map-insert balances user u1000) (err u1))
    (ok true)))

(map-delete map-name key)

(define-map users principal { data: uint })

(define-public (remove-user (user principal))
  (begin
    (asserts! (is-eq tx-sender contract-owner) (err u401))
    (map-delete users user)
    (ok true)))

;; Clear data
(define-public (clear-balance)
  (begin
    (map-delete balances tx-sender)
    (ok true)))

(define-private (function-name (arg-name arg-type)...) body)

(define-private (calculate-fee (amount uint))
  (/ (* amount u3) u100)) ;; 3% fee

(define-public (transfer-with-fee (recipient principal) (amount uint))
  (let ((fee (calculate-fee amount)))
    (try! (stx-transfer? (- amount fee) tx-sender recipient))
    (try! (stx-transfer? fee tx-sender contract-owner))
    (ok true)))

;; Helper functions
(define-private (is-valid-amount (amount uint))
  (and (> amount u0) (<= amount u1000000)))

(define-public (function-name (arg-name arg-type)...) body)

(define-public (transfer (recipient principal) (amount uint))
  (begin
    (asserts! (not (is-eq tx-sender recipient)) (err u1))
    (asserts! (> amount u0) (err u2))
    (try! (ft-transfer? my-token amount tx-sender recipient))
    (ok true)))

;; State-changing function
(define-public (set-name (new-name (string-ascii 50)))
  (begin
    (map-set user-names tx-sender new-name)
    (ok new-name)))

(define-read-only (function-name (arg-name arg-type)...) body)

(define-read-only (get-balance (user principal))
  (default-to u0 (map-get? balances user)))

(define-read-only (calculate-reward (staked uint) (days uint))
  (/ (* staked days u5) u36500)) ;; ~5% APY

;; Complex query
(define-read-only (get-user-info (user principal))
  {
    balance: (get-balance user),
    profile: (map-get? user-profiles user),
    is-admin: (is-eq user contract-owner)
  })

(if condition true-branch false-branch)

(if (> u10 u5)
  "Greater"
  "Not greater") ;; Returns "Greater"

;; Conditional logic
(define-public (withdraw (amount uint))
  (let ((balance (get-balance tx-sender)))
    (if (>= balance amount)
      (begin
        (map-set balances tx-sender (- balance amount))
        (ok amount))
      (err u1))))

(match value
  some-name some-branch
  none-branch)

(match (map-get? balances tx-sender)
  balance (ok balance)
  (err u404))

;; Response matching
(match (ft-transfer? token u100 tx-sender recipient)
  success (ok "Transfer successful")
  error (err error))

;; Nested matching
(define-read-only (get-user-name (user principal))
  (match (map-get? user-profiles user)
    profile (match (get name profile)
      name (ok name)
      (err u1))
    (err u404)))

(begin expr1 expr2... last-expr)

(begin
  (print "Starting")
  (var-set counter u1)
  (ok true))

;; Multiple operations
(define-public (initialize)
  (begin
    (asserts! (is-eq tx-sender contract-owner) (err u401))
    (var-set is-initialized true)
    (map-set admins tx-sender true)
    (print { event: "initialized", by: tx-sender })
    (ok true)))

(let ((name1 value1) (name2 value2)...) body)

(let ((x 10) (y 20))
  (+ x y)) ;; Returns 30

;; Complex calculations
(define-public (calculate-reward (days uint))
  (let (
    (balance (get-balance tx-sender))
    (rate u5) ;; 5% annual
    (reward (/ (* balance rate days) u36500)))
    (begin
      (map-set rewards tx-sender reward)
      (ok reward))))

(asserts! condition thrown-value)

(define-public (transfer (amount uint) (recipient principal))
  (begin
    (asserts! (> amount u0) (err u1))
    (asserts! (not (is-eq tx-sender recipient)) (err u2))
    (asserts! (<= amount (get-balance tx-sender)) (err u3))
    (ok true)))

;; Guard functions
(define-public (admin-only-function)
  (begin
    (asserts! (is-eq tx-sender contract-owner) (err u401))
    ;; Admin logic here
    (ok true)))

(ok value)

(ok u42) ;; Returns (ok u42)
(ok { status: "success", value: u100 })

;; Success response
(define-public (deposit (amount uint))
  (begin
    (map-set balances tx-sender 
      (+ (get-balance tx-sender) amount))
    (ok amount)))

(err value)

(err u404) ;; Returns (err u404)
(err { code: u500, message: "Internal error" })

;; Error responses
(define-public (withdraw (amount uint))
  (let ((balance (get-balance tx-sender)))
    (if (>= balance amount)
      (ok amount)
      (err u1)))) ;; Insufficient balance

(some value)

(some u42) ;; Returns (some u42)
(some "Hello") ;; Returns (some "Hello")

;; Return optional
(define-read-only (find-user (id uint))
  (if (map-get? users id)
    (some (map-get? users id))
    none))

(unwrap! optional-or-response thrown-value)

(unwrap! (some u42) (err u1)) ;; Returns u42
(unwrap! none (err u404)) ;; Throws (err u404)

;; Safe access
(define-public (transfer-from-map (recipient principal))
  (let ((amount (unwrap! (map-get? pending-transfers tx-sender) (err u404))))
    (try! (ft-transfer? token amount tx-sender recipient))
    (map-delete pending-transfers tx-sender)
    (ok amount)))

(unwrap-err! response thrown-value)

(unwrap-err! (err u404) u0) ;; Returns u404
(unwrap-err! (ok u42) u0) ;; Returns u0

;; Error handling
(define-public (handle-error)
  (let ((error-code (unwrap-err! (process-action) u0)))
    (print { error: error-code })
    (ok error-code)))

(unwrap-panic optional-or-response)

(unwrap-panic (some u42)) ;; Returns u42
(unwrap-panic none) ;; Runtime panic

;; Critical unwrap
(define-read-only (get-critical-value)
  (unwrap-panic (map-get? critical-config "version")))

(unwrap-err-panic response)

(unwrap-err-panic (err u404)) ;; Returns u404
(unwrap-err-panic (ok u42)) ;; Runtime panic

;; Force error
(define-read-only (get-error-code)
  (unwrap-err-panic (always-fails)))

(is-ok response)

(is-ok (ok u42)) ;; Returns true
(is-ok (err u1)) ;; Returns false

;; Check success
(define-read-only (was-successful (tx-id uint))
  (is-ok (map-get? transaction-results tx-id)))

(is-err response)

(is-err (err u404)) ;; Returns true
(is-err (ok u42)) ;; Returns false

;; Check failure
(define-read-only (has-error (result (response uint uint)))
  (is-err result))

(is-some optional)

(is-some (some u42)) ;; Returns true
(is-some none) ;; Returns false

;; Check existence
(define-read-only (user-exists (user principal))
  (is-some (map-get? users user)))

(is-none optional)

(is-none none) ;; Returns true
(is-none (some u42)) ;; Returns false

;; Check absence
(define-read-only (is-available (name (string-ascii 50)))
  (is-none (map-get? reserved-names name)))

(try! response)

(try! (ok u42)) ;; Returns u42
(try! (err u404)) ;; Propagates (err u404)

;; Chain operations
(define-public (complex-operation (amount uint))
  (begin
    (try! (check-preconditions amount))
    (try! (process-payment amount))
    (try! (update-records))
    (ok true)))

(default-to default optional)

(default-to u0 (some u42)) ;; Returns u42
(default-to u0 none) ;; Returns u0

;; Safe defaults
(define-read-only (get-balance-safe (user principal))
  (default-to u0 (map-get? balances user)))

(define-fungible-token token-name [total-supply])

(define-fungible-token my-token)
(define-fungible-token limited-token u1000000)

;; With helper functions
(define-public (get-balance (user principal))
  (ok (ft-get-balance my-token user)))

(ft-mint? token amount recipient)

(ft-mint? my-token u100 tx-sender)

;; Mint with checks
(define-public (mint-tokens (amount uint) (recipient principal))
  (begin
    (asserts! (is-eq tx-sender contract-owner) (err u401))
    (ft-mint? my-token amount recipient)))

(ft-burn? token amount owner)

(ft-burn? my-token u50 tx-sender)

;; Burn own tokens
(define-public (burn (amount uint))
  (ft-burn? my-token amount tx-sender))

(ft-transfer? token amount sender recipient)

(ft-transfer? my-token u50 tx-sender recipient)

;; Transfer with memo
(define-public (transfer-memo (amount uint) (recipient principal) (memo (buff 32)))
  (begin
    (print { action: "transfer", amount: amount, memo: memo })
    (ft-transfer? my-token amount tx-sender recipient)))

(ft-get-balance token principal)

(ft-get-balance my-token tx-sender) ;; Returns uint

;; Balance check
(define-read-only (has-sufficient-balance (user principal) (required uint))
  (>= (ft-get-balance my-token user) required))

(ft-get-supply token)

(ft-get-supply my-token) ;; Returns uint

;; Supply metrics
(define-read-only (get-supply-info)
  {
    current: (ft-get-supply my-token),
    max: u1000000,
    remaining: (- u1000000 (ft-get-supply my-token))
  })

(define-non-fungible-token token-name identifier-type)

(define-non-fungible-token my-nft uint)
(define-non-fungible-token complex-nft { id: uint, serial: (buff 20) })

;; NFT with metadata
(define-map nft-metadata uint { 
  name: (string-ascii 50),
  uri: (string-ascii 200)
})

(nft-mint? token identifier recipient)

(nft-mint? my-nft u1 tx-sender)

;; Mint with metadata
(define-public (mint-with-metadata (id uint) (name (string-ascii 50)) (uri (string-ascii 200)))
  (begin
    (try! (nft-mint? my-nft id tx-sender))
    (map-set nft-metadata id { name: name, uri: uri })
    (ok id)))

(nft-burn? token identifier owner)

(nft-burn? my-nft u1 tx-sender)

;; Burn with ownership check
(define-public (burn-nft (id uint))
  (let ((owner (unwrap! (nft-get-owner? my-nft id) (err u404))))
    (asserts! (is-eq owner tx-sender) (err u403))
    (nft-burn? my-nft id tx-sender)))

(nft-transfer? token identifier sender recipient)

(nft-transfer? my-nft u1 tx-sender recipient)

;; Safe transfer
(define-public (transfer (id uint) (recipient principal))
  (let ((owner (unwrap! (nft-get-owner? my-nft id) (err u404))))
    (asserts! (is-eq owner tx-sender) (err u403))
    (nft-transfer? my-nft id tx-sender recipient)))

(nft-get-owner? token identifier)

(nft-get-owner? my-nft u1) ;; Returns (optional principal)

;; Ownership check
(define-read-only (is-owner (id uint) (user principal))
  (match (nft-get-owner? my-nft id)
    owner (is-eq owner user)
    false))

(stx-transfer? amount sender recipient)

(stx-transfer? u1000000 tx-sender recipient) ;; Transfer 1 STX

;; Payment function
(define-public (pay (amount uint) (recipient principal))
  (begin
    (asserts! (> amount u0) (err u1))
    (stx-transfer? amount tx-sender recipient)))

(stx-transfer-memo? amount sender recipient memo)

(stx-transfer-memo? u1000000 tx-sender recipient 0x12345678)

;; Payment with reference
(define-public (pay-invoice (amount uint) (recipient principal) (invoice-id (buff 16)))
  (stx-transfer-memo? amount tx-sender recipient 
    (concat 0x494e56 invoice-id))) ;; "INV" prefix

(stx-burn? amount sender)

(stx-burn? u1000000 tx-sender)

;; Burn mechanism
(define-public (burn-stx (amount uint))
  (begin
    (asserts! (> amount u0) (err u1))
    (stx-burn? amount tx-sender)))

(stx-get-balance principal)

(stx-get-balance tx-sender) ;; Returns uint

;; Balance check
(define-read-only (can-afford-fee (user principal) (fee uint))
  (>= (stx-get-balance user) fee))

(stx-account principal)

(stx-account tx-sender)
;; Returns { locked: uint, unlock-height: uint, unlocked: uint }

;; Get available balance
(define-read-only (get-available-balance (user principal))
  (get unlocked (stx-account user)))

(sha256 data)

(sha256 0x616263) ;; Returns SHA-256 of "abc"
(sha256 "Hello") ;; Hash string

;; Create hash commitment
(define-public (commit-hash (data (buff 32)))
  (let ((hash (sha256 data)))
    (map-set commitments tx-sender hash)
    (ok hash)))