Loading
Loading
Neuron registration trends
Financial institutions and trading firms face a persistent challenge: sourcing reliable price predictions across multiple asset classes and forecasting horizons without building proprietary infrastructure or relying on single-vendor models. Centralized prediction services introduce latency, vendor lock-in, and opacity in how predictions are scored and weighted. Teams cannot easily benchmark their models against peer approaches, nor can they contribute predictions without surrendering algorithmic control.
A decentralized network of independent miners can address this by submitting encrypted predictions to validators who independently score them using consistent, transparent methodologies. Encryption ensures miners cannot observe competing predictions before submission; timelock cryptography prevents validators from peeking at payloads before a predetermined maturation window. Validators use walk-forward machine learning to score each miner's predictions on calibration, feature quality, and predictive power, then aggregate scores across challenges and set on-chain rewards proportional to demonstrated performance.
MANTIS (Bittensor Subnet 123) implements this model with 12 parallel prediction challenges spanning binary direction (1-hour horizons on ETH, forex pairs, and precious metals), volatility regime classification (17-dimensional quantile predictions on ETH and BTC at 1-hour and 6-hour horizons), barrier-hit timing (barrier-crossing prediction on ETH), multi-asset range breakouts (33 crypto assets), cross-sectional return ranking (33 assets, 4-hour horizon), funding-rate ranking (20 assets, 8-hour horizon), and capital-at-risk bracket trades (BTC, variable 1–336 hour regimes with collateral locking and significance-gated payout). Validators score miners using L2 logistic regression with challenge-specific feature selection and importance weighting, apply sybil resistance via coefficient regularization, and set on-chain weights weekly after EMA smoothing to reduce variance.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
MANTIS (Bittensor Subnet 123) is a machine learning prediction market that scores miners on their ability to forecast price movements across multiple asset classes and prediction horizons. Validators collect encrypted miner embeddings, decrypt them after a timelock maturation window, and use walk-forward L2 logistic regression with challenge-specific scoring paths (binary classification, volatility regimes, cross-sectional ranking, barrier hits, range breakouts, and capital-at-risk bracket trades) to compute per-miner salience scores, which are aggregated by challenge weight and smoothed via EMA before being set on-chain as validator weights.
Validators run a periodic sampling and scoring pipeline: (1) Every SAMPLE_EVERY (5) blocks, call cycle.get_miner_payloads() to download encrypted V2 JSON commits from Cloudflare R2, validate host/key/size constraints, store ciphertexts in ledger.py (SQLite). (2) After PAYLOAD_MATURITY_BLOCKS (50400, ~1 week), decrypt via Drand IBE (drand-tlock public path) once the beacon signature is available; dual-path encryption ensures no early observation. (3) Store (embedding, price) pairs in challenge_data table; prices recorded at submission time, embeddings backfill post-decrypt. (4) Every WEIGHT_CALC_INTERVAL (1000) blocks, iterate training data via ledger.iter_challenge_training_data(), call model.multi_salience() which dispatches to per-challenge scorers (binary, lbfgs, hitfirst, range_breakout_multi, xsec_rank, funding_xsec, flow), compute per-miner salience vectors per challenge. (5) Normalize, weight by challenge importance, aggregate, apply EMA smoothing (α=0.15). (6) Every WEIGHT_SET_INTERVAL (360) blocks, set on-chain weights via subtensor.set_weights(). FLOW adds: flow_collateral.py reads live FlowCollateralPool (0xD9c80... on chain 964) for per-bet sizing; flow.py resolves bracket trades post-maturity against multi-venue klines; significance gate (rolling t-stat) gates payment; weekly settlement daemon (team-run, separate) closes bets and pays winners pro rata. Scoring modules (bucket_forecast.py, xsec_rank.py, funding_xsec.py, range_breakout.py, hitfirst.py, flow.py) implement domain-specific walk-forward or static regression paths; all feed salience scalars back to model.py for aggregation.
Incentivizing cooperative prediction
This information was auto-extracted from the GitHub repository and may be incomplete or out of date. Always refer to the subnet's GitHub repository for the latest instructions.
Validators walk forward through historical price data, train per-miner L2 logistic models on training windows, evaluate on validation windows, and compute coefficient-based importance scores. LBFGS challenges use dual paths (classifier + quantile) blended 75/25. Binary challenges use ElasticNet meta-models on OOS predictions.
MULTI-BREAKOUT gates on AUC > 0.5 then scores via episode-balanced L2 logistic. XSEC-RANK and FUNDING-XSEC reformulate assets as binary (return > median) and pool across assets with walk-forward meta-model selection. FLOW is non-regression: miners post bracket trades (direction, Kelly fraction, stop, targets, horizon); R (return) is path-penalized and tail-amplified into per-regime EWMA; payment is gated on significance (rolling t ≥ 1.25 clear, 0.5 latch).
L2 regularization provides sybil resistance; clones split weight pro rata. Final weights computed every WEIGHT_CALC_INTERVAL blocks, set every WEIGHT_SET_INTERVAL blocks with EMA smoothing (α=0.15).
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
https//mantis123.com/dashboard/
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 1h ago (hourly snapshot)
Miners submit encrypted predictions (embeddings) to R2 via payload commits. No GPU required for encryption/submission. Heavy CPU/RAM needed for model training offline to generate competitive embeddings.
CUDA disabled by default (env config) to ensure cross-hardware numerical reproducibility. Validators run single-threaded BLAS (OMP_NUM_THREADS=1) for stable weight calculations. Requires SQLite WAL mode storage with periodic database snapshots for publishing.
Clone the MANTIS subnet repository
git clone https://github.com/opentensor/validators.git && cd validators/subnet_123_mantis
Install dependencies including timelock-wasm from source (NOT via pip)
./install_reqs.sh
Install Python dependencies (torch 2.7.1, scikit-learn, boto3, etc.)
pip install -r requirements.txt
Configure environment: HOTKEY, WALLET, R2 credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY), FLOW_COLLATERAL_ADDRESS if trading FLOW
cp .env.example .env && nano .env
Generate and encrypt embeddings for a challenge; writes V2 JSON with dual encryption (owner + timelock drand)
python generate_and_encrypt.py --challenge ETH-1H-BINARY --payload-file embeddings.json
Run miner: samples block chain, encrypts embeddings, posts commits to R2 on schedule
python neurons/miner.py --netuid 123
Daemonize miner with PM2 (optional but recommended for production)(optional)
pm2 start neurons/miner.py --name miner -- --netuid 123
Open a FLOW collateral slot and fund it (required only if submitting FLOW bracket trades)(optional)
python flow_post.py fund --hotkey myhotkey --amount 0.5 --chain mainnet
Clone the MANTIS subnet repository
git clone https://github.com/opentensor/validators.git && cd validators/subnet_123_mantis
Install dependencies including timelock-wasm from source
./install_reqs.sh
Install Python dependencies
pip install -r requirements.txt
Configure: HOTKEY, WALLET, FLOW_COLLATERAL_RPC (archive endpoint), FLOW_COLLATERAL_ADDRESS (live pool on chain 964)
cp .env.example .env && nano .env
Initialize SQLite datalog with challenge metadata and download remote archives (datalog.db, flow_datalog.db, latest_prices.json)
mkdir -p .storage && python -c 'from ledger import DataLog; DataLog.init_db()'
Run validator: samples miner payloads every SAMPLE_EVERY blocks, decrypts after maturity, computes per-challenge salience via model.multi_salience(), applies EMA, sets weights on-chain
python neurons/validator.py --netuid 123
Daemonize validator with PM2 for production(optional)
pm2 start neurons/validator.py --name validator -- --netuid 123
Set custom weight-setting interval (default WEIGHT_SET_INTERVAL=360 blocks)(optional)
pm2 start python neurons/validator.py -- --netuid 123 --update-interval 360