# NeuraMesh

> The market layer for tokenized AI compute on Sui + Walrus.

NeuraMesh turns verified future GPU capacity into programmable usage claims. Providers issue capacity-backed claims with explicit hardware, region, delivery window, and quantity. Buyers or autonomous agents can receive, transfer, split, merge, and redeem those claims for real workloads; models, inputs, results, and receipts are referenced through Walrus.

## Why now

BlackRock Digital Assets Research argues that compute is emerging as a potentially large digital-asset market and that standardized claims on compute capacity may support financing, transfer, collateral use, and programmable settlement.[1] NeuraMesh implements the narrow, testable first step: **prepaid usage entitlements for reserved inference capacity**—not speculative futures, equity, or a revenue-share token.

Read the full product and risk case in [PIVOT.md](./PIVOT.md).

## Protocol model

```text
Provider GPU node
      │ registers + attests hardware
      ▼
CapacityPool (hardware · region · window · max units · collateral)
      │ issues only within declared cap
      ▼
ComputeClaim (transferable usage right, measured in GPU-seconds)
      │ split / merge / transfer / redeem
      ▼
ComputeReservation ── workload blob ──► NeuraMesh node agent
      │                                      │
      └──── on-chain settlement ◄── result / receipt on Walrus
```

## Components

| Component | File | Role |
|---|---|---|
| Protocol state | `core.move` | Fees, counters, shared constants |
| Provider registry | `registry.move` | Nodes, stake, capability metadata, reputation |
| Spot jobs | `marketplace.move` | Job creation, assignment, deadlines, settlement |
| Tokenized capacity | `tokenization.move` | Capacity pools, transferable claims, redemption |
| Node agent | `agent.py` | Job discovery, workload execution, Walrus I/O |
| SDK prototype | `neuramesh-client.ts` | Sui RPC and transaction builders |
| Product prototype | `neuramesh-dashboard.html` | Pivot narrative and compute-contract designer |

## Claim lifecycle

1. A registered provider creates a collateralized `CapacityPool` for one hardware class, region, and delivery window.
2. The provider issues `ComputeClaim` objects. The contract rejects issuance beyond the pool cap.
3. A claim moves with Sui object transfer semantics and can be split or merged with matching claims.
4. The holder redeems during the delivery window and references a Walrus workload blob.
5. The provider executes the workload and settles the shared reservation with a result blob.
6. Settlement reduces outstanding capacity. Expired unredeemed claims can also release capacity.

## Current status

This repository is a **protocol prototype**, not a deployed market:

- package IDs in the SDK remain placeholders;
- hardware attestation and metering are not yet production-grade;
- `tokenization.move` has not been compiled in this environment because the Sui CLI is not installed;
- the node agent still contains production integration TODOs;
- no live liquidity, providers, jobs, or investment returns are represented.

## Run the product prototype

```bash
python3 -m http.server 8080
```

Then open `http://localhost:8080/neuramesh-dashboard.html`.

## Next acceptance test

The pivot is technically validated only when two testnet wallets complete this sequence:

`create pool → issue claim → transfer claim → redeem claim → execute workload → store result on Walrus → settle reservation`

## Risk boundary

A token does not verify physical capacity by itself. Mainnet launch requires independent capability attestation, objective metering, over-commit protection, disputes/refunds, collateral slashing, compliance review, and clear legal characterization. See [PIVOT.md](./PIVOT.md#non-negotiable-risks).

## License

MIT

## Sources

[1] https://www.blackrock.com/us/individual/literature/whitepaper/the-machine-native-economy.pdf — BlackRock — The Machine-Native Economy