;; Title: blaze
;; Version: welsh-predict-v1
;; Description:
;; Implementation of a prediction market vault for the Stacks blockchain that
;; supports both on-chain and off-chain (signed) operations.
;; Allows users to create markets, make predictions, and claim rewards.
;; Market resolution is controlled by the vault deployer or authorized admins.
;; Each prediction is tracked as a non-fungible token receipt.
;; This version adds support for Blaze subnet tokens and signed operations.
;; Traits
;; (impl-trait 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.betting-traits-v0.betting-vault-trait)
;; (impl-trait 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.nft-trait.nft-trait)
;; Constants
(define-constant DEPLOYER tx-sender)
(define-constant CONTRACT (as-contract tx-sender))
(define-constant ERR_UNAUTHORIZED (err u403))
(define-constant ERR_INVALID_OPERATION (err u400))
(define-constant ERR_MARKET_EXISTS (err u401))
(define-constant ERR_MARKET_NOT_FOUND (err u404))
(define-constant ERR_MARKET_CLOSED (err u405))
(define-constant ERR_MARKET_NOT_RESOLVED (err u406))
(define-constant ERR_NOT_WINNER (err u408))
(define-constant ERR_INVALID_OUTCOME (err u409))
(define-constant ERR_INVALID_TOKEN_ID (err u410))
(define-constant ERR_NO_PREDICTION (err u411))
(define-constant ERR_PREDICTION_NOT_FOUND (err u412))
(define-constant ERR_INSUFFICIENT_BALANCE (err u413))
(define-constant ERR_INVALID_SIGNATURE (err u414))
(define-constant ERR_NONCE_TOO_LOW (err u415))
(define-constant ERR_CONSENSUS_BUFF (err u416))
(define-constant ERR_TOO_MANY_OPERATIONS (err u417))
(define-constant ERR_PREDICTION_FAILED (err u418))
(define-constant ERR_CLAIM_FAILED (err u419))
(define-constant PRECISION u1000000)
(define-constant ADMIN_FEE u50000) ;; 5% fee to admin who resolves the market
(define-constant MAX_BATCH_SIZE u200) ;; Maximum number of operations in a batch
;; Opcodes (0xA* range to avoid LP conflicts)
(define-constant OP_PREDICT 0xA1) ;; Make a prediction
(define-constant OP_CLAIM_REWARD 0xA3) ;; Claim rewards
;; Constants for SIP-018 structured data
(define-constant structured-data-prefix 0x534950303138)
(define-constant message-domain-hash (sha256 (unwrap-panic (to-consensus-buff?
{
name: "blaze",
version: "welsh-predict-v1",
chain-id: chain-id
}
))))
(define-constant structured-data-header (concat structured-data-prefix message-domain-hash))
;; Define NFT for prediction receipts
(define-non-fungible-token prediction-receipt uint)
;; Data structures
(define-map markets (string-ascii 64) {
creator: principal,
name: (string-ascii 64),
description: (string-ascii 128),
outcome-names: (list 16 (string-ascii 32)),
outcome-pools: (list 16 uint),
total-pool: uint,
is-open: bool,
is-resolved: bool,
winning-outcome: uint,
resolver: (optional principal), ;; Admin who resolved the market
creation-time: uint,
resolution-time: uint
})
;; Map to track receipts by receipt ID (no predictor field)
(define-map predictions uint {
market-id: (string-ascii 64),
outcome-id: uint,
amount: uint
})
;; Map for authorized oracles/admins
(define-map authorized-admins principal bool)
;; Next token ID counter
(define-data-var next-receipt-id uint u1)
;; Token metadata URI
(define-data-var token-uri (string-utf8 256) u"https://charisma.rocks/sip9/predictions/receipt.json")
;; --- NFT Trait Functions ---
(define-public (transfer (receipt-id uint) (sender principal) (recipient principal))
(begin
(asserts! (is-eq tx-sender sender) ERR_UNAUTHORIZED)
(nft-transfer? prediction-receipt receipt-id sender recipient)
))
(define-read-only (get-last-token-id)
(ok (- (var-get next-receipt-id) u1)))
(define-read-only (get-token-uri (token-id uint))
(ok (some (var-get token-uri))))
(define-public (set-token-uri (new-uri (string-utf8 256)))
(begin
(asserts! (is-eq tx-sender DEPLOYER) ERR_UNAUTHORIZED)
(ok (var-set token-uri new-uri))
))
(define-read-only (get-owner (token-id uint))
(ok (nft-get-owner? prediction-receipt token-id)))
;; --- Core Functions ---
;; (define-public (execute (amount uint) (opcode (optional (buff 16))))
;; (let (
;; (op-buffer (default-to 0x00 opcode))
;; (op-type (get-byte op-buffer u0))
;; (market-id (get-byte op-buffer u1))
;; (outcome-id (get-byte op-buffer u2))
;; (receipt-id amount))
;; (if (is-eq op-type (buff-to-uint-le OP_PREDICT)) (make-prediction market-id outcome-id amount)
;; (if (is-eq op-type (buff-to-uint-le OP_CLAIM_REWARD)) (claim-reward receipt-id)
;; ERR_INVALID_OPERATION))))
;; (define-read-only (quote (amount uint) (opcode (optional (buff 16))))
;; (let (
;; (op-buffer (default-to 0x00 opcode))
;; (op-type (get-byte op-buffer u0))
;; (market-id (get-byte op-buffer u1))
;; (outcome-id (get-byte op-buffer u2))
;; (receipt-id amount))
;; (if (is-eq op-type (buff-to-uint-le OP_PREDICT)) (quote-prediction market-id outcome-id)
;; (if (is-eq op-type (buff-to-uint-le OP_CLAIM_REWARD)) (quote-reward receipt-id)
;; ERR_INVALID_OPERATION))))
;; --- Market Management Functions ---
;; Create a new prediction market (standard function, not an opcode)
(define-public (create-market
(market-id (string-ascii 64))
(name (string-ascii 64))
(description (string-ascii 128))
(outcome-names (list 16 (string-ascii 32))))
(begin
;; Check if market ID already exists
(asserts! (is-none (map-get? markets market-id)) ERR_MARKET_EXISTS)
;; Initialize empty outcome pools
(let ((empty-pools (list
u0 u0 u0 u0 u0 u0 u0 u0
u0 u0 u0 u0 u0 u0 u0 u0)))
;; Create a new prediction market
(map-set markets market-id {
creator: tx-sender,
name: name,
description: description,
outcome-names: outcome-names,
outcome-pools: empty-pools,
total-pool: u0,
is-open: true,
is-resolved: false,
winning-outcome: u0,
resolver: none,
creation-time: stacks-block-height,
resolution-time: u0
})
(ok {
market-id: market-id,
creator: tx-sender,
creation-time: stacks-block-height
})
)
)
)
;; Close a market (no more predictions allowed)
(define-public (close-market (market-id (string-ascii 64)))
(let ((market (unwrap! (map-get? markets market-id) ERR_MARKET_NOT_FOUND)))
;; Only vault deployer or authorized admin can close
(asserts! (or
(is-eq tx-sender DEPLOYER)
(default-to false (map-get? authorized-admins tx-sender)))
ERR_UNAUTHORIZED)
;; Update market status
(map-set markets market-id (merge market { is-open: false }))
(ok true)
)
)
;; Resolve a market (determine correct outcome)
(define-public (resolve-market (market-id (string-ascii 64)) (winning-outcome uint))
(let (
(sender tx-sender)
(market (unwrap! (map-get? markets market-id) ERR_MARKET_NOT_FOUND))
(admin-fee (/ (* (get total-pool market) ADMIN_FEE) PRECISION)) ;; Calculate 5% fee
)
;; Only vault deployer or authorized admin can resolve
(asserts! (or
(is-eq sender DEPLOYER)
(default-to false (map-get? authorized-admins sender)))
ERR_UNAUTHORIZED)
;; Check that outcome is valid
(asserts! (< winning-outcome (len (get outcome-names market))) ERR_INVALID_OUTCOME)
;; Pay admin fee directly to resolver
(try! (as-contract (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1 transfer admin-fee CONTRACT sender none)))
;; Update market state
(map-set markets market-id (merge market {
is-open: false,
is-resolved: true,
winning-outcome: winning-outcome,
resolver: (some sender),
resolution-time: stacks-block-height
}))
(ok true)
)
)
;; --- Execute Functions ---
(define-public (make-prediction (market-id (string-ascii 64)) (outcome-id uint) (amount uint))
(let (
(sender tx-sender)
(market (unwrap! (map-get? markets market-id) ERR_MARKET_NOT_FOUND))
(receipt-id (var-get next-receipt-id)))
;; Verify market is open
(asserts! (get is-open market) ERR_MARKET_CLOSED)
;; Verify outcome ID is valid
(asserts! (< outcome-id (len (get outcome-names market))) ERR_INVALID_OUTCOME)
;; Transfer tokens to contract
(try! (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1 transfer amount sender CONTRACT none))
;; Store receipt data without predictor field
(map-set predictions receipt-id {
market-id: market-id,
outcome-id: outcome-id,
amount: amount
})
;; Mint NFT receipt
(try! (nft-mint? prediction-receipt receipt-id sender))
;; Update outcome pools
(let (
(current-pools (get outcome-pools market))
(current-pool (default-to u0 (element-at? current-pools outcome-id)))
(updated-pool (+ current-pool amount))
(updated-pools (replace-at? current-pools outcome-id updated-pool)))
;; Update market state
(map-set markets market-id (merge market {
outcome-pools: (unwrap-panic updated-pools),
total-pool: (+ (get total-pool market) amount)
}))
;; Increment receipt ID counter
(var-set next-receipt-id (+ receipt-id u1))
(ok {
dx: market-id,
dy: updated-pool,
dk: receipt-id
})
)
)
)
;; Make a prediction using a signed transaction from the Blaze subnet token
(define-public (signed-predict
(signet {signature: (buff 65), nonce: uint})
(market-id (string-ascii 64))
(outcome-id uint)
(amount uint)
)
(let (
;; Get the signer principal from the signet verification function in the subnet contract
(signer-principal (unwrap! (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1
verify-transfer-signer
signet
CONTRACT ;; The target of the transfer is this contract
amount)
ERR_INVALID_SIGNATURE))
(market (unwrap! (map-get? markets market-id) ERR_MARKET_NOT_FOUND))
(receipt-id (get nonce signet)))
;; Verify market is open
(asserts! (get is-open market) ERR_MARKET_CLOSED)
;; Verify outcome ID is valid
(asserts! (< outcome-id (len (get outcome-names market))) ERR_INVALID_OUTCOME)
;; Check if signer has sufficient balance in the blaze subnet
(asserts! (>= (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1 get-balance signer-principal) amount)
ERR_INSUFFICIENT_BALANCE)
;; Transfer tokens from signer to contract using signed-transfer from subnet
(try! (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1
signed-transfer
signet ;; We use the same signet for the transfer
CONTRACT ;; The target is this contract
amount)) ;; Same amount we're using for the prediction
;; Store receipt data
(map-set predictions receipt-id {
market-id: market-id,
outcome-id: outcome-id,
amount: amount
})
;; Mint NFT receipt to the signer (not tx-sender)
(try! (nft-mint? prediction-receipt receipt-id signer-principal))
;; Update outcome pools
(let (
(current-pools (get outcome-pools market))
(current-pool (default-to u0 (element-at? current-pools outcome-id)))
(updated-pool (+ current-pool amount))
(updated-pools (replace-at? current-pools outcome-id updated-pool)))
;; Update market state
(map-set markets market-id (merge market {
outcome-pools: (unwrap-panic updated-pools),
total-pool: (+ (get total-pool market) amount)
}))
;; Increment receipt ID counter
(var-set next-receipt-id (+ receipt-id u1))
(ok {
dx: market-id,
dy: updated-pool,
dk: receipt-id
})
)
)
)
;; Helper function that attempts to execute a signed prediction and returns a boolean
;; Used for batch operations to continue processing even if some predictions fail
(define-private (try-predict
(operation {
signet: {signature: (buff 65), nonce: uint},
market-id: (string-ascii 64),
outcome-id: uint,
amount: uint
})
)
(match (signed-predict
(get signet operation)
(get market-id operation)
(get outcome-id operation)
(get amount operation)
)
success true
error false
)
)
(define-public (claim-reward (receipt-id uint))
(let (
(sender tx-sender)
(reward-quote (unwrap-panic (quote-reward receipt-id)))
(total-reward (get dy reward-quote)))
;; Verify user owns the NFT receipt
(asserts! (is-eq (some sender) (nft-get-owner? prediction-receipt receipt-id)) ERR_UNAUTHORIZED)
;; Verify has rewards
(asserts! (> total-reward u0) ERR_NOT_WINNER)
;; Transfer reward to user
(try! (as-contract (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1 transfer total-reward CONTRACT sender none)))
;; Burn the NFT receipt (marks as claimed)
(try! (nft-burn? prediction-receipt receipt-id sender))
(ok {
dx: (get dx reward-quote),
dy: total-reward,
dk: receipt-id
})
)
)
;; Claim a reward using a signed transaction
(define-public (signed-claim-reward
(signet {signature: (buff 65), nonce: uint})
(receipt-id uint)
)
(let (
;; Get the signer principal from our verify-receipt-signer function
(signer-principal (unwrap! (verify-receipt-signer signet receipt-id) ERR_INVALID_SIGNATURE))
(reward-quote (unwrap-panic (quote-reward receipt-id)))
(total-reward (get dy reward-quote)))
;; Verify signer owns the NFT receipt
(asserts! (is-eq (some signer-principal) (nft-get-owner? prediction-receipt receipt-id)) ERR_UNAUTHORIZED)
;; Verify has rewards
(asserts! (> total-reward u0) ERR_NOT_WINNER)
;; Transfer reward to user through the subnet contract using SIP-010 standard interface
;; For rewards, we use the standard transfer since the contract is the sender
(try! (as-contract (contract-call? 'SP2ZNGJ85ENDY6QRHQ5P2D4FXKGZWCKTB2T0Z55KS.blaze-welsh-v1
transfer
total-reward ;; amount
CONTRACT ;; from (as-contract makes this the sender)
signer-principal ;; to
none))) ;; memo
;; Burn the NFT receipt (marks as claimed)
(try! (nft-burn? prediction-receipt receipt-id signer-principal))
(ok {
dx: (get dx reward-quote),
dy: total-reward,
dk: receipt-id
})
)
)
;; Helper function that attempts to execute a signed claim reward and returns a boolean
;; Used for batch operations to continue processing even if some claims fail
(define-private (try-claim-reward
(operation {
signet: {signature: (buff 65), nonce: uint},
receipt-id: uint
})
)
(match (signed-claim-reward
(get signet operation)
(get receipt-id operation)
)
success true
error false
)
)
;; --- Quote Functions ---
(define-read-only (quote-prediction (market-id (string-ascii 64)) (outcome-id uint))
(match (map-get? markets market-id)
market
(if (not (get is-open market))
(ok {
dx: market-id,
dy: u0,
dk: u0
})
(let (
(outcome-pools (get outcome-pools market))
(outcome-pool (default-to u0 (element-at? outcome-pools outcome-id))))
(ok {
dx: market-id,
dy: outcome-pool, ;; Current pool for this outcome
dk: (get total-pool market) ;; Total pool across all outcomes
})
))
ERR_MARKET_NOT_FOUND)
)
(define-read-only (quote-reward (receipt-id uint))
(let (
(prediction (unwrap! (map-get? predictions receipt-id) ERR_PREDICTION_NOT_FOUND))
(market-id (get market-id prediction))
(market (unwrap! (map-get? markets market-id) ERR_MARKET_NOT_FOUND)))
;; Verify market is resolved
(if (get is-resolved market)
(let (
(outcome-id (get outcome-id prediction))
(amount (get amount prediction))
(total-pot (get total-pool market))
(winning-outcome (get winning-outcome market))
(winning-pool (default-to u0 (element-at? (get outcome-pools market) winning-outcome))))
;; Calculate reward with fee deduction in one step to preserve precision
;; First multiply by (PRECISION - ADMIN_FEE) to apply 95% factor
;; Then divide by PRECISION to normalize
;; This is equivalent to: (amount * total_pot * 0.95) / winning_pool
(let (
(net-reward (if (and (is-eq outcome-id winning-outcome) (> winning-pool u0))
(/ (* (* amount total-pot) (- PRECISION ADMIN_FEE)) (* winning-pool PRECISION))
u0)))
(ok {
dx: market-id,
dy: net-reward,
dk: receipt-id
})
)
)
(ok {
dx: market-id,
dy: u0,
dk: u0
})
)
)
)
;; ;; --- Helper Functions ---
;; (define-read-only (get-byte (opcode (buff 16)) (position uint))
;; (buff-to-uint-le (default-to 0x00 (element-at? opcode position))))
;;; Generate a hash of the structured data for redeeming a prediction receipt.
;;; This authorizes the receipt to be redeemed from the signer's account.
;;; Returns:
;;; - (ok (buff 32)) with the hash of the structured data on success
;;; - `ERR_CONSENSUS_BUFF` if the structured data cannot be converted to a
;;; consensus buff
(define-read-only (make-redeem-receipt-hash
(receipt-id uint)
(nonce uint)
)
(let (
(structured-data { receipt-id: receipt-id, nonce: nonce })
(data-hash (sha256 (unwrap! (to-consensus-buff? structured-data) ERR_CONSENSUS_BUFF)))
)
(ok (sha256 (concat structured-data-header data-hash)))
)
)
;;; Recovers a principal from a signature and message hash
;;; Returns:
;;; - (ok principal) with the address of the signer
;;; - ERR_INVALID_SIGNATURE if recovery fails
(define-read-only (get-signer
(hash (buff 32))
(signature (buff 65))
)
(match (secp256k1-recover? hash signature)
public-key (principal-of? public-key)
error ERR_INVALID_SIGNATURE
)
)
;;; Verify a receipt redemption signet and return the signer principal
;;; This is a convenience function that combines make-redeem-receipt-hash and get-signer
;;; Returns:
;;; - (ok principal) with the address of the signer for the given signet + receipt
;;; - Error if signature verification fails
(define-read-only (verify-receipt-signer
(signet {signature: (buff 65), nonce: uint})
(receipt-id uint)
)
(let (
(signature (get signature signet))
(nonce (get nonce signet))
(hash (unwrap! (make-redeem-receipt-hash receipt-id nonce) ERR_CONSENSUS_BUFF))
)
(get-signer hash signature)
)
)
;; --- Admin Functions ---
(define-public (add-admin (admin principal))
(begin
(asserts! (is-eq tx-sender DEPLOYER) ERR_UNAUTHORIZED)
(ok (map-set authorized-admins admin true))
)
)
(define-public (remove-admin (admin principal))
(begin
(asserts! (is-eq tx-sender DEPLOYER) ERR_UNAUTHORIZED)
(ok (map-set authorized-admins admin false))
)
)
;; --- Market Info Functions ---
(define-read-only (get-market-info (market-id (string-ascii 64)))
(match (map-get? markets market-id)
market (ok market)
ERR_MARKET_NOT_FOUND)
)
(define-read-only (get-receipt-info (receipt-id uint))
(match (map-get? predictions receipt-id)
receipt
(match (nft-get-owner? prediction-receipt receipt-id)
owner (ok (merge receipt { predictor: owner }))
(err ERR_INVALID_TOKEN_ID))
(err ERR_INVALID_TOKEN_ID))
)
;; --- Batch Functions ---
;; Batch process multiple signed predictions at once
(define-public (batch-predict
(operations (list 200 {
signet: {signature: (buff 65), nonce: uint},
market-id: (string-ascii 64),
outcome-id: uint,
amount: uint
}))
)
(let
(
(results (map try-predict operations))
)
(asserts! (<= (len operations) MAX_BATCH_SIZE) ERR_TOO_MANY_OPERATIONS)
(ok results)
)
)
;; Batch process multiple signed reward claims at once
(define-public (batch-claim-reward
(operations (list 200 {
signet: {signature: (buff 65), nonce: uint},
receipt-id: uint
}))
)
(let
(
(results (map try-claim-reward operations))
)
(asserts! (<= (len operations) MAX_BATCH_SIZE) ERR_TOO_MANY_OPERATIONS)
(ok results)
)
)
;; --- Initialization ---
(begin
;; Initialize admin
(map-set authorized-admins DEPLOYER true)
)