DAI Miner Network

Decentralized compute layer for Artificial Intelligence, AI-agents, automations and robotics. Decentralized, encrypted, anonymous AI.

---

Quick Start

GUI (recommended for non-technical users)

Download the latest .deb / .AppImage / Windows installer from miner.iamai.kg.

Inference runs in-process via QVAC (the @qvac/sdk dependency) — there's no separate engine to install. On first launch the model (default qwen3-1.7b) is downloaded and loaded automatically.

The desktop app includes Chat (private sync / public async job queue, blockchain history autocomplete), Explorer (blocks, addresses, completed jobs), and P2P exchange tabs. Every node ships builtin MCP tools (public-apis + onion search) plus a set of no-auth HTTP MCPs (docs, ads, catalog, …). Complex chat is planned as a short catalog-first cascade (candidate cards, not full schemas); extra servers use the standard mcpServers JSON format (command, args, env, optional url + headers) in Settings.

Model still downloading? The miner still works — chat and skill queries fall back to peer miners on the network that already have the model.

CLI

# Install dependencies once
npm install

# Copy example config and fill in your wallet + bootnodes
cp config.example.json config.json

# Start mining
npm start
# or: node src/cli.js start

Docker

docker run -v ~/.dai-miner:/root/.dai-miner ghcr.io/dai/miner:latest

---

Configuration

Config file is loaded from the first location that exists (in order):

1. DAI_CONFIG env var (full path)
2. ./config.json (project root — convenient after git clone)
3. ./.dai-miner/config.json
4. <script-dir>/.dai-miner/config.json
5. ~/.dai-miner/config.json

Minimal example:

{
  "bootnodes": ["https://miner.iamai.kg"],
  "inferenceMode": "auto",
  "model": "qwen3-1.7b",
  "walletApiPort": 3456
}

The miner creates a DAI wallet automatically on first run and stores it in ~/.dai-miner/wallets/. To use an existing wallet, set daiWallet to its DAI address.

Field	Default	Description
daiWallet	auto-created	DAI address that earns rewards (created on first run if not set)
bootnodes	production bootnode	Peer discovery + chain sync entry points
inferenceMode	auto	cpu / gpu / auto
model	qwen3-1.7b	QVAC model id/alias (qwen3-0.6b…qwen3-8b) or a GGUF URL
walletApiPort	3456	Port for the local API server
computeEnabled	true	Set false to run as relay-only
region	auto	Geographic region tag for job routing
autoStart	true	Start mining immediately on launch

RPC endpoints can be configured per-chain under the rpc key — see config.example.json.

Multi-device model pooling

QVAC SDK 0.21+ can split one model's layers across several machines over llama.cpp's RPC backend, so a model too big for any single device can still load — set the same qvacCluster.topic on each of your own devices (phone, laptop, desktop) under qvacCluster in config.json. Off by default: the channel is unauthenticated, so this is for a private group of devices you control, never the open miner network. See _comment_qvacCluster in config.example.json for the fields.

---

Architecture

┌──────────────────────────────────────────────────────────────────┐
│                   App Layer  (iamai.kg)                   │
│   Frontend  ·  Profiles  ·  Voting  ·  Feedback        │
└───────────────────────────┬──────────────────────────────────────┘
                            │  submits scan jobs  ▼  reads results
┌───────────────────────────▼──────────────────────────────────────┐
│                    DAI Miner Network  (this repo)                │
│                                                                  │
│   ┌──────────────┐  P2P gossip (blocks, txs, status)            │
│   │  Miner Node  │◄────────────────────────────►  Miner Node   │
│   │              │                                              │
│   │ • PoW mining │  ← race to compute first valid verdict →    │
│   │ • LLM brain  │                                              │
│   │ • Skills     │  ← publish/run on-demand agent logic →      │
│   │ • P2P market │  ← peer-to-peer DAI/fiat exchange →         │
│   │ • Chain sync │  ← bootnode for peer discovery / catch-up → │
│   │ • Wallet API │                                              │
│   └──────────────┘                                              │
│                                                                  │
│   IPFS durability layer (chain snapshots, brain state, peers)   │
└──────────────────────────────────────────────────────────────────┘

Block Contents

Each block contains:

• height, previousHash, timestamp, minerWallet
• scanResults[] — mined job results (verdict scans, skill outputs, compute replies): requestId, verdict, profile, reasoning, minerWallet, signature
• stateTransitions[] — on-chain state deltas applied by this block: job-submitted (public job queue metadata + promptPreview), escrow, brain updates, brain-state-root
• transactions[] — signed DAI token transfers with nonces
• coinbaseReward — up to 1 DAI per block, paid to the nodes that did the AI work. Reward model v2 (active above REWARD_V2_HEIGHT in src/rewards/reward.js): if compute work exists, the proposer keeps a small PROPOSER_CUT (~10%) and the rest is split among workers weighted by delivered compute (a deterministic token estimate, so splitting into many identities earns nothing extra); a block with no real work mints only a small keepalive (KEEPALIVE_UDAI), not a full DAI, so emission tracks demand. Blocks at/below the flag-day boundary keep the legacy 60/40 split (history stays valid). Amounts are consensus-recomputed by every node in src/consensus/coinbase-validator.js — gossiped amounts are never trusted.
• nonce, difficulty, chainWork — PoW fields (chainWork is cumulative hex bigint)
• stateRoot — SHA-256 of sorted {address, balance, nonce} at this height
• brainStateRoot — SHA-256 of weights.json + pools.json at this height
• minerSignature, minerSigningPublicKey — ed25519 signature over block hash

---

What Syncs Between Nodes

Data	How
New blocks	P2P gossip new-block (flood-fill, TTL=4)
Pending transactions	P2P gossip new-tx
Node status (methodsHash, region, load)	P2P gossip node-status
Chain history (cold start)	HTTP pull from bootnode /chain/blocks + IPFS snapshot fallback
Verified signals (canonical set + hash)	HTTP from iamai.kg + IPFS fallback
Brain feedback events	Peer-to-peer push + bootnode /brain/events
Signal weight updates	Same as brain feedback
Peer records (host:port)	Bootnode /peers + IPFS peer directory
IPFS CIDs (chain, brain, peers)	Bootnode /ipfs/latest + /ipfs/update

---

Blockchain Properties

Property	Implementation
Consensus	Longest-chain (heaviest chainWork)
PoW	SHA-256, target N leading zeros, auto-adjusts to 30 s/block
Fork resolution	Orphan pool + chainWork comparison; reorg with journal rollback
Transactions	Account model with nonces (replay protection) + ed25519 signatures
Double-spend	Pending balance lock in mempool + nonce validation at application
Block signatures	Proposer signs block hash with ed25519 identity key
Result signatures	Every scan result signed by computing miner

---

Wallet API (port 3456 by default)

Every miner exposes an HTTP API for the mobile wallet and external tools. Amounts are in μDAI (1 DAI = 1 000 000 000 μDAI).

Chain & Wallet

Endpoint	Description
GET /status	Node status, chain height, reputation
GET /api/miner/info	Detailed miner info (version, uptime, peers)
GET /api/wallet/balance?address=<addr>	Balance in μDAI + assets map of stablecoin holdings ({ aiGEL: { raw, display } })
GET /api/assets	On-chain asset registry: DAI + the 5 stablecoins (tickers, decimals, display names, per-currency gas prices)
GET /api/wallet/nonce?address=<addr>	Current nonce for transaction signing
GET /api/wallet/transactions?address=<addr>	Transaction history
GET /api/wallet/history?address=<addr>	Full history with block confirmations
GET /api/wallet/jobs?address=<addr>&limit=20	Public job history for a wallet — joins job-submitted transitions with mined scanResults; returns {jobs, latestSkillMemory, chatTurns}
POST /api/wallet/send	Transfer DAI ({from, to, amount, privateKey})
POST /api/wallet/register-key	Register an ed25519 signing key for an address
POST /api/tx/submit	Submit a pre-signed DAITransaction
GET /api/tx/pending	Inspect mempool

Chat context (private vs public)

Mode	Context source
Private	In-memory chat history + _skillMemory from the last inline skill run on this device; chat runs synchronously
Public	Same session memory plus on-chain job history for the paying wallet (job-submitted + mined scanResults), via GET /api/wallet/jobs?address=...; paid jobs are queued asynchronously

Public follow-ups (e.g. "give me the link") can resolve from chain-stored skill outputs when the session is new or on another device. Prompt text on chain is stored as promptPreview (max 500 chars) on each job-submitted transition. The desktop app's Chat tab shows a queue pill while public jobs are pending.

Blockchain Explorer

Browse the local chain from the Electron Explorer tab or via HTTP:

Endpoint	Description
GET /api/explorer/blocks?page=0&limit=20	Recent blocks (newest first); each entry includes jobCount when the block contains mined results
GET /api/explorer/block/:height	Full block JSON (scanResults, stateTransitions, transactions, hash, miner, reward)
GET /api/explorer/search?q=<query>	Lookup by block height, tx/block hash, or wallet address

Address search returns balance, recent DAI transfers, and completed jobs for that wallet. Block detail shows completed jobs in block (from scanResults) and any job submissions (job-submitted transitions not yet mined in the same block).

Chat history search (Meilisearch — bundled, auto-starts)

Meilisearch is mandatory and starts automatically with every miner node (like the model download). On first run the binary is downloaded to ~/.dai-miner/bin/meilisearch; data lives in ~/.dai-miner/meilisearch-data. If port 7700 is already in use (e.g. your own Docker container), the node reuses that instance.

As you type in Chat, the miner searches indexed blockchain job history (promptPreview, replies, skill outputs) and suggests past questions. Repetitive prompts can return a cached on-chain reply without re-running compute.

Remote clients (mobile wallet, other UIs) call the miner wallet API — not Meilisearch directly:

Endpoint	Description
GET /api/search/suggest?q=<prefix>&wallet=<addr>&limit=8	Autocomplete — past prompts + reply snippets
GET /api/search/history-match?q=<message>&wallet=<addr>	Full cached reply when the prompt closely matches history

POST /chat/ask also checks history automatically (similarity ≥ 0.86) and may return { fromChainHistory: true }.

Indexing: On startup, each new block, and when jobs complete. NDJSON mirror: ~/.dai-miner/search/chat-history.ndjson.

"meilisearch": {
  "mandatory": true,
  "autoStart": true,
  "port": 7700,
  "bindHost": "127.0.0.1",
  "indexJobs": "dai-chat-history"
}

Meilisearch listens on localhost only; expose search to the network via walletApiPort (default 3456) with localOnly: false.

The mobile DAI Wallet app uses the same APIs on any connected miner (Ask AI tab).

Stablecoins (multi-currency)

The chain carries four regional stablecoins alongside DAI — aiGEL, KGST, aiETB, aiBTN. They use 2 decimals (1 aiGEL = 100 raw units); DAI keeps 9 (1 DAI = 1e9 μDAI). Supply is minted once in the genesis allocation to the treasury address — there is no runtime mint; future supply changes are network upgrades.

On-chain currencies: DAI, aiGEL, KGST, aiETB, aiBTN. P2P market also supports: USDT, USDC, GELT (off-chain).

• Transfers: POST /api/wallet/send and /api/tx/submit accept a currency field (omit for DAI). A transaction's hash includes currency ONLY when non-DAI, so every historical DAI tx/signature stays valid.
• Job fees: any job payload may set currency — the fee floor is priced per currency (config.gasPrices overridable) and the miner receives exactly the currency paid (no conversion). The signed payment proof binds the currency (6th key of the payment hash when non-DAI).
• P2P: on-chain stablecoins are tradable base assets. When both legs are on-chain (e.g. KGST/aiGEL) the trade settles atomically in one p2p-swap-filled transition — no payment-sent step, proceeds go directly to the taker's own dai address (no receival-wallet input). Off-chain legs (bank transfer, USDT…) keep the manual escrow/release flow.

Jobs (scan requests, skills, compute)

Endpoint	Description
POST /job	Submit a job, returns {jobId, statusUrl, resultUrl}. type: 'verdict' (default) is a scan request; type: 'skill' runs a skill; type: 'compute' runs a user-specified model (and optional dataset) — see below.
GET /job/:id/status	Poll: queued / computing / done / error
GET /job/:id/result	Full verdict + profile + evidence when done
GET /jobs	List active jobs
POST /gossip	Receive P2P gossip envelopes from peers

skill and compute jobs always require a fee (maxBudget > 0, in raw units of the job's currency — μDAI for DAI, the default) and a signed payment proof — the node rejects the request outright (the job never runs) unless it includes a valid Ed25519 signature, from a key already registered via POST /api/wallet/register-key, over a hash binding the payment to that exact jobId + this node's wallet + maxBudget + the requester's current nonce (GET /api/wallet/nonce). This debits the requester's DAI balance and pays the miner network; there is no unverified fallback for these job types. verdict jobs may optionally carry the same maxBudget/paymentTx fields, but a fee isn't required for them (the default identity scan / LLM chat is free).

Pricing (gas). Paid jobs are metered per AI compute token at gasPrice μDAI per token — default 1 μDAI/token (μDAI is the smallest unit, so this is the price floor). Since 1 DAI = 1e9 μDAI, 1 DAI buys up to 1,000,000,000 tokens. The fee is tokensUsed × gasPrice and can never be less than the tokens the job actually used (e.g. 1,000 tokens ⇒ ≥ 1,000 μDAI); unused budget is refunded. A job whose maxBudget can't cover its token cost is rejected up front with 402 FEE_TOO_LOW.

DAI price. DAI has no fixed or oracle price — the only reference is the best open P2P order. GET /api/p2p/price[?quoteCurrency=USDT-TRC20] returns the market price (best bid/ask/mid) derived solely from live P2P orders.

A compute job looks like:

{
  "type": "compute",
  "model": "llama3.1:8b",
  "dataset": "some-org/some-dataset",
  "payload": { "prompt": "Summarize the top 5 rows" },
  "maxBudget": 500000000,
  "requesterAddress": "dai...",
  "paymentTx": { "txHash": "...", "signature": "..." }
}

The SDKs build and sign paymentTx for you — see runCompute() / submitJob() in sdk-js.

Fee estimation (/api/estimate)

The eth_estimateGas of DAI jobs. Send the same fields a job or chat request carries and get back the AI tokens the whole pipeline will use, the minimum fee this node accepts, and a recommended budget — before you sign or escrow anything. Read-only: no skill, MCP tool or model runs, and attachments are sized, not stored.

curl -s localhost:3456/api/estimate -d '{
  "prompt": "summarise the attached report and compare it with the latest news",
  "attachments": [{ "name": "report.md", "text": "…" }],
  "currency": "DAI"
}'
# GET works for quick prompts: /api/estimate?prompt=…&currency=DAI&mcp=shop__search

Field	Meaning
prompt / messages	A compute job's prompt, or an OpenAI-style messages[] (type: "chat", floors at the prompt alone)
history, requesterAddress	Prior turns; with an address the on-chain public turns the executor merges in are counted too
attachments	Same shapes as chat (text, contentBase64, dataUrl). Text is inlined and measured; images are not metered
skillId, type: "skill"	A specific skill (else the router picks one from the prompt, as a job would)
mcp	MCP tool names (server__tool) to run in a cascade
dataset	An installed Hugging Face dataset — the exact rows the job would inject are measured
currency, maxOutputTokens, route, model, address	Fee currency (quoted off the live P2P book), output reserve, false to skip routing, model, /job address

The response has tokens (prompt, output, skillCompute, total, each {min, max}), calls (every model call the pipeline makes), a breakdown per contributor tagged measured / bounded / assumed, fees.minimum (what the node rejects below) and fees.recommended (max of that and the pipeline's worst case), outputCap, and warnings. Anything whose size only exists after running — what a skill fetched, what an MCP tool returned — is bounded by the executor's own caps rather than guessed. Routed plans are predicted from the deterministic router; the live model-planner may choose differently.

SDKs: estimate() in the JS, Python, Rust, Kotlin and Swift SDKs wraps this endpoint (typed results; works against remote nodes without a local node).

Skills

Skills are on-demand agent modules that extend what miners can compute. Builtin skills include dai_identity, read_farcaster, read_zora, read_paragraph, code_audit, and web_search.

Economics: deploy a public skill for 1 DAI (escrowed for network code_audit); the community stakes toward a 10 DAI graduation threshold before the skill goes live on all nodes.

Endpoint	Description
GET /api/skills	List available skills with context summaries and economics (proposeFeeDai, graduationThresholdDai)
GET /api/skills/prefs	Skill staking preferences for an address
POST /api/skills/propose	Propose a new skill {manifest, code, private} — 1 DAI for public proposals
POST /api/skills/:id/stake	Stake DAI toward graduation (10 DAI total activates the skill)

Chat & Skill Routing

Endpoint	Description
POST /chat/route	Route a message to the best matching skill {message, budget, wallet}
POST /chat/ask	Full AI reply — routes to a skill or falls back to free chat {message, wallet, requesterAddress, history}; may return cached chain reply

LLM & Brain

Endpoint	Description
POST /api/chat	Streaming chat via local QVAC (Ollama-compatible response shape)
POST /api/generate	QVAC generate (Ollama-compatible response shape)
GET /api/models	List models available on this node (built-in + loaded + registry)
GET /api/brain/state	Current weights count, feedback count, model info
GET /api/brain/weights	Full weights.json
POST /api/brain/feedback	Submit human correction {address, aiVerdict, correction, comment, signals}
POST /api/brain/vote	Submit signal weight vote {method, voteType, vote, stakeWeight}
POST /api/brain/sync/event	Receive brain event pushed by a peer

P2P Exchange

Peer-to-peer DAI trading with on-chain escrow. Orders are matched locally; escrow is settled on the DAI chain.

Endpoint	Description
GET /api/p2p/currencies	List supported quote currencies
GET /api/p2p/orders	Open order book (filters: side, quoteCurrency)
GET /api/p2p/orders/my?address=<addr>	Orders created by this address
GET /api/p2p/orders/:id	Single order detail
POST /api/p2p/orders	Create a new order {side, baseCurrency, quoteCurrency, amount, price, address}
POST /api/p2p/orders/:id/cancel	Cancel an open order
POST /api/p2p/orders/:id/select	Taker selects an order to trade
GET /api/p2p/trades/my?address=<addr>	Active and past trades for an address
GET /api/p2p/trades/:id	Single trade detail
POST /api/p2p/trades/:id/:action	Advance trade state (payment-sent, release, cancel, dispute)
POST /api/p2p/local-auth	Sign a P2P auth payload with the node's local wallet

Push Notifications

Endpoint	Description
POST /api/push/register	Register an Expo push token {address, token}
POST /api/push/send	Send a push notification to a registered address
GET /api/push/tokens	List registered tokens (admin)

---

IPFS Durability Layer

Miners automatically pin data to IPFS and share CIDs via the bootnode.

What	When	CID shared as
Chain snapshot (last 500 blocks)	Every 100 blocks	chain
Brain state (weights + pools)	After every feedback/vote + every 30 min	brain
Own peer record (host:port signed)	After every bootnode registration	selfPeer
Peer directory (all known peers)	Bootnode pins every 60 s after changes	peers

CIDs are cached locally in ~/.dai-miner/ipfs_cid_cache.json. If every bootnode is unreachable at startup, the node uses cached CIDs to discover peers from IPFS and to pull chain snapshots for catch-up — not just for peer discovery.

Configure a pinning service via env vars:

IPFS_API_URL=https://api.pinata.cloud/pinning/pinFileToIPFS
IPFS_API_KEY=yourPinataJWT

Without configuration, the node uses a local Kubo daemon if one is running.

---

Bootnode Endpoints

GET  /chain/tip
GET  /chain/blocks?from=0&to=100
POST /submit-block
POST /register          (signed peer registration)
GET  /peers             (verified peer list with host:port)
POST /brain/events      (receive signed brain events)
GET  /brain/events?since=<ts>
GET  /brain/stats
GET  /ipfs/latest       (latest chain, brain, peers CIDs)
POST /ipfs/update       (miners push new CIDs)

Running your own bootnode:

node src/bootnode.js --port 8080 --data-dir ~/.dai-bootnode

---

Running Tests

npm test                  # unit tests (vitest)
npm run test:watch        # watch mode
npm run test:integration  # end-to-end (requires dev/ checker)

Tests cover: P2P gossip, block/result signatures, chainWork fork resolution, transactions + nonces, double-spend protection, PoW mining + abort, balance journal rollback, job deduplication, on-chain job indexing (chain-job-index), and chat history search (chat-history-search).

---

Troubleshooting

All heavy dependencies (the Electron binary and the LLM model) are downloaded over the network. On a slow or unstable connection a download can drop midway. The app now retries and resumes automatically, but if you still get stuck:

Electron failed to install correctly on npm start The Electron binary (~100 MB) didn't finish downloading during npm install (npm install doesn't fail when this happens). Re-run one of:

# Re-run the official downloader (no resume — may take a few tries)
node node_modules/electron/install.js

# Or use a faster mirror if the official host is slow/blocked
ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/ node node_modules/electron/install.js
# Windows (PowerShell): $env:ELECTRON_MIRROR='https://npmmirror.com/mirrors/electron/'; node node_modules/electron/install.js

A postinstall check prints these same instructions automatically when the binary is missing.

Model download fails at startup QVAC downloads the model in-process on first run and retries automatically. If it can't finish (slow/unstable connection), just restart the miner — the download resumes. You can also pick a smaller model in ~/.dai-miner/config.json:

{ "model": "qwen3-0.6b" }

Until the model is ready, public-mode chat/skills fall back to peer miners that already have it.

---

Building

npm run build:bin              # standalone binaries (pkg)
npm run build:deb              # .deb package (requires fpm)
npm run build:electron         # Electron desktop app (current platform)
npm run build:electron:linux   # Linux: AppImage + .deb (x64 + arm64)
npm run build:electron:win     # Windows: NSIS installer + portable
npm run build:electron:mac     # macOS: .dmg (x64 + arm64)
npm run build:electron:all     # all platforms

The .deb needs no inference engine — QVAC runs in-process and the model downloads on first run.

---

Project Layout

src/
  core/           block.js, scanRequest.js, transaction.js
  chain/          chain-job-index.js (join job-submitted + scanResults for wallet/explorer)
  search/         meilisearch-server.js (auto-start), chat-history-search.js
  consensus/      pow.js, chain-selection.js
  network/        p2p-gossip.js
  signals/        methods-manager.js (canonical signal set sync)
  compute/        dai-adapter.js → delegates to dev/src checker + brain
  brain/          brain-sync.js (network-wide brain state sync)
  storage/        chain-store.js, balance-journal.js, ipfs-store.js,
                  ipfs-sync.js, dataset-sync.js
  wallet/         wallet.js (ed25519 keys, nonces, balances)
  rewards/        reward.js (1 DAI/block, 60/40 split)
  jobs/           job-queue.js, geo.js, gas-estimator.js
  validation/     result-validator.js
  rpc/            resolver.js, networks.js
  p2p/            order-store.js, escrow.js  ← P2P exchange
  skills/
    manager.js       skill lifecycle (install, stake, run)
    loader.js        load builtin + user skills at startup
    sandbox/         skill-runner.js (sandboxed execution)
    builtin/         dai_identity.md, read_farcaster.md, read_zora.md,
                     read_paragraph.md, code_audit.md
  miner-node.js   main orchestrator
  bootnode.js     peer discovery + chain relay + IPFS registry
  cli.js

electron/         GUI desktop app (Electron 31)
  renderer/
    index.html    main UI (Home, Logs, Chat, Explorer, P2P, Settings tabs)
    renderer.js   frontend logic (chat queue, history autocomplete, model selector, explorer)
    i18n.js       internationalization strings
  main.cjs        IPC + QVAC model warm-up + window management
  preload.js      context bridge

landing/          Promotional landing page + binary downloads
  binaries/       dai-miner-linux-x64.deb / .AppImage / windows-x64.exe

test/             vitest unit tests
scripts/          build and dev helper scripts