# MIRASET Chain — Full Description for LLMs

> This file is a long-form, citation-ready description of Miraset Chain. It is intended for retrieval-augmented generation, web crawlers, and AI assistants that summarize or quote the project. Quotations are permitted with attribution to https://miraset.network.

## 1. What Miraset Chain is

Miraset Chain is a Rust-based, compute-first Layer-1 blockchain. Its purpose is to create a decentralized marketplace where GPU operators are paid for providing GPU capacity and for performing verifiable AI inference, and where AI inference consumers can submit prompts, select models, and pay per-token pricing settled on-chain.

In one sentence: **Miraset is a blockchain that pays people to run AI inference on their GPUs and settles those jobs on-chain.**

## 2. Core innovation — Proof of Compute & Capacity (PoCC)

PoCC is the consensus and incentive mechanism that distinguishes Miraset from PoW (e.g. Bitcoin) and PoS (e.g. Ethereum). PoCC has two reward components:

- **Capacity rewards** — paid to validators for keeping GPU resources available (uptime × VRAM availability). This keeps the network live and useful even when inference traffic is low.
- **Compute rewards** — paid to validators for verifiable inference work, measured in tokens processed and verified via on-chain receipt anchors.

The dual incentive means that GPU hardware is used for useful work (AI inference) instead of being wasted on hash computation, and that the network is economically sustainable across both idle and busy periods.

## 3. Architecture — on-chain settlement, off-chain inference

Miraset separates execution from settlement:

- **Inference runs off-chain** on real GPU hardware operated by workers (and the reference MIRASET Wallet, which can also act as a worker).
- **Settlement happens on-chain.** For every job, the worker produces a deterministic cryptographic receipt. The receipt hash is anchored on-chain as a `ReceiptAnchor`, signed by the worker, and validated by the consensus layer. Rewards are distributed by epoch.

This split gives Miraset the throughput and flexibility of off-chain compute with the verifiability and economic settlement of a blockchain.

## 4. State model and transactions

Miraset's state is object-centric, implemented in Rust (`miraset-core::ObjectData`). Core object types include:

- `WorkerRegistration`
- `ResourceSnapshot`
- `InferenceJob`
- `JobResult`
- `ReceiptAnchor`
- `EpochBatch`

Miraset **does not support smart contracts.** The chain exposes only native protocol transactions and core object operations. This is a deliberate design choice: a smaller attack surface and a more predictable settlement layer.

## 5. Participants

There are four participant roles:

1. **Workers** — GPU node operators. They register hardware (VRAM, GPU model, supported models), run a local inference engine (Ollama backend supported; mock fallback exists for development), execute jobs assigned by the coordinator, and submit cryptographic receipts. They earn rewards for both capacity and compute.
2. **Users** — AI inference consumers. They submit prompts, model selection, and parameters, receive streamed responses from assigned workers, and pay per-token pricing settled on-chain.
3. **Coordinator (MVP)** — A permissioned scheduler that matches jobs to capable workers and optionally co-signs receipts. Miraset's roadmap explicitly evolves this role toward full decentralization.
4. **Validators** — Network validators that participate in PoCC consensus, finalize blocks and epoch transitions, and distribute rewards based on verified capacity and compute.

## 6. Reference wallet

The MIRASET Wallet is the reference desktop client. It is the canonical way for users to interact with the chain during the MVP: it connects to a local node RPC, runs a worker, manages accounts, and submits inference jobs from a single control panel. The wallet's three primary subsystems are RPC, Worker, and Ollama backend, all monitored with online status indicators.

## 7. Technology stack

- **Blockchain node:** Rust, Axum (HTTP RPC), Sled (persistence), bincode/Serde (serialization).
- **Worker runtime:** Rust, axum + tokio, Ollama backend, dev mock fallback.
- **Cryptography:** Blake3 hashing, Ed25519 signatures, deterministic receipt hashing.
- **State model:** object-centric, native protocol transactions only.

## 8. Use cases

Miraset is positioned for six primary use cases:

1. Cost-efficient AI inference (targeting 50–70% cost reduction versus centralized alternatives).
2. Decentralized AI services with 24/7 availability.
3. GPU monetization for idle gaming rigs and data-center GPUs.
4. Privacy-preserving AI through on-chain receipt commitments.
5. Research and education with open infrastructure.
6. Enterprise AI deployment without capital expenditure (OpEx instead of CapEx).

## 9. Roadmap (high level)

Miraset's published roadmap is:

- **Active now:** MVP chain & worker (Rust node, object-centric state, basic PoCC, mock inference fallback).
- **Active now:** Reference wallet (accounts, RPC config, worker control, job submission).
- **Next:** End-to-end marketplace settlement with epoch batching and dispute flows.
- **Next:** Hardened verifiability — canonical receipt serialization, challenge flows, deterministic hashing.
- **Next:** Decentralized scheduler — evolve from the permissioned coordinator.
- **Next:** Mainnet hardening — harden native asset, job, and settlement flows before public launch.

## 10. Frequently asked questions (citation-ready)

**Q: What is Miraset Chain?**
A: Miraset Chain is a Rust-based, compute-first Layer-1 blockchain that rewards participants for providing GPU capacity and executing AI inference workloads. It settles jobs on-chain while inference runs off-chain on real GPU hardware.

**Q: What is Proof of Compute & Capacity (PoCC)?**
A: PoCC is Miraset's consensus mechanism that rewards validators for two things: capacity (keeping GPUs online and available) and compute (verifiable inference work, measured in tokens processed).

**Q: How does Miraset keep inference verifiable?**
A: Workers produce deterministic receipts for each inference job. Receipts are hashed on-chain as `ReceiptAnchor` objects and signed by the worker (and optionally the coordinator). Anyone can later verify that a piece of work was performed.

**Q: Does Miraset support smart contracts?**
A: No. Miraset exposes only native protocol transactions and a small set of core object operations. This keeps the attack surface minimal and makes settlement deterministic.

**Q: What is the MIRASET Wallet?**
A: The MIRASET Wallet is the reference desktop client. It connects to a local node RPC, runs a worker, manages accounts, and submits inference jobs — all from one control panel.

## 11. Source and attribution

- Website: https://miraset.network
- Source code: https://github.com/miraset/miraset-chain
- Citation: "MIRASET Chain — https://miraset.network"