The Decentralized Data Center

01The problem

The world has a shortage of accessible GPU compute and, at the same time, an enormous amount of it sitting idle — in home rigs, in small studios, in racks that are busy eight hours a day. The gap is not hardware. It is trust.

A renter handing money to a stranger's machine has to believe three things at once: that the GPU is real and is the model claimed, that it will actually be available when the job starts, and that if it is not, there is recourse. Centralised clouds answer all three with a brand. Decentralised markets have mostly answered them with self-reported specs and an uptime dashboard, which is why the good hardware stays where the brands are.

WRAITHGRID answers each of the three with a mechanism rather than a promise: hardware proves itself cryptographically before it can list, keeps proving it on a clock, and stands behind every job with collateral a quorum can slash.

02Architecture: a soul and a body

Two tokens exist per physical GPU, and the split between them is the whole design.

SOUL — the identity

A soulbound token (ERC-5192) minted once per physical card. It is non-transferable by construction: there is no code path that moves one between wallets. It records the hardware fingerprint, the device key that machine signs with, its verified class, and the timestamp of its last proof of life.

Crucially, reputation is keyed to the hardware fingerprint, not to the token. A provider can retire a card and enrol it again, but it comes back with its record — the completed jobs, the failures, and any ban. Identity laundering by re-minting does not work.

SHELL — the licence

A freely tradeable ERC-721 representing a claim on a slice of what that GPU earns. Licences bind to the hardware and the operator that issued them, so a brief outage and a re-enrolment does not destroy what a holder bought, while a card that genuinely changes hands does not carry the previous operator's obligations to a stranger.

Supporting contracts

• AttestorSet — the root of trust. An M-of-N quorum of independent attestors, with one shared EIP-712 domain and a strict-majority threshold enforced in code.
• GridMarket — listings, escrow, bonds, job lifecycle, disputes, and pull-payment settlement.
• GridConfig — every economic parameter, each hard-capped so governance can tune but never expropriate.
• SoulVault — custody for mint deposits, staked through a liquid-staking vault.

03Proof of compute

Enrolment is not a form. An attestor issues a challenge that could not have been precomputed: a random seed, a matrix dimension, an iteration count, and a random projection vector. The machine must compute C = A·B in fp16 on the GPU and return v = C·r before a deadline derived from the class of card being claimed.

Verification uses Freivalds' algorithm: the attestor checks v == A·(B·r) with two streaming O(n²) passes instead of redoing O(n³) of work. Checking is thousands of times cheaper than cheating, and cheating costs the same as being honest. No GPU is needed to verify.

The random matrices are generated by a counter-based PRNG that both the prover (Python, on the GPU) and the verifier (JavaScript, on the attestor) implement identically. A parity test pins them together, because any drift between the two would fail every honest machine on the network.

04The 72-hour rule

There are two different questions inside "is it online", and conflating them makes a GPU market either expensive or unreliable. Is it up right now is needed in seconds and does not need to be on chain. Is this still a real, present machine at all is needed in days and absolutely does.

A soul must produce a device-signed proof of life at least every 72 hours. Miss it and isLive() returns false — computed, never stored, so it takes effect the instant the clock passes with no keeper, no transaction, and nobody watching. The machine cannot list, cannot be rented, and cannot mint licences.

Why heartbeats cannot be faked ahead of time

Each proof commits to the hash of a recent block, and the accepted block number only ever moves forward. A month of heartbeats cannot be signed in advance and dripped out from a machine that is switched off, and a captured heartbeat cannot be replayed later.

Why this is safe for honest operators

Accepting a job is itself a proof of life, so a busy machine never lapses. And the three-day cooldown that stops a provider retiring out of an in-flight dispute is deliberately not applied to a liveness lapse: a power cut is not a dispute-dodge, and making a four-hour outage cost four days off the grid would be indefensible. Coming back is immediate — but you come back with your record.

A permissionless expire() lets anyone sweep a lapsed soul, freeing its fingerprint for whoever holds that card next and paying the caller a small bounty out of the expired deposit. Cleanup funds itself.

05Collateral and disputes

Providers stake collateral per card. Accepting a job locks a bond out of it, sized as a share of the job's value. The renter's escrow settles on one of three paths:

1. Confirmation — the renter got its compute and says so; settlement is immediate.
2. Timeout — the renter went quiet; anyone may close the job once the dispute window passes with no dispute raised.
3. Ruling — the renter disputes, and an attestor quorum signs a resolution refunding up to 100% of the price and slashing up to 100% of the bond as damages on top.

Collateral is keyed by (hardware, staker) rather than by token id. Two properties fall out of that, both intentional: a provider's money survives the soul being burned by retirement, revocation or the liveness rule, and withdrawal is self-authorising — a caller can only ever address its own bucket, so there is no ownership check to get wrong.

06Compute licences

A licence comes in two flavours, chosen when it is minted.

A yield licence pays its holder a fixed share of the gross revenue of every job that GPU settles, for as long as they hold it — plus a referral cut on jobs they source. A compute licence instead entitles the holder to a number of GPU-seconds per epoch on that card, redeemable at zero marginal cost: the purchase price is the prepayment.

The guardrails that make the second safe to sell:

• Oversell cap — total entitlements on a card cannot exceed a fixed share of wall-clock per epoch. A provider cannot promise more hours than it has.
• Same bond, same teeth — a redeemed job locks the provider's bond exactly like a paid one. The licence is a collateralised claim, not a promise.
• Use it or lose it — entitlements expire per epoch, so a provider can plan capacity.

Aggregate licence share per GPU is capped at 25% by default and can never exceed 30%, a constant in the contract. Combined with the protocol fee and referral, the provider always keeps the clear majority of what a job earns — asserted as a fuzz test, not a policy.

07The mint deposit

Minting a soul requires locking MON. The protocol stakes it for the life of the NFT, keeps the staking yield, and returns the principal when the card leaves. Note what that is not: it is not a fee. What the provider pays is the opportunity cost of the float.

One mechanism, three jobs:

• It makes spamming fake hardware cost capital as well as compute — and the deposit scales with the class being claimed, because faking an H100 is worth more than faking a 4090.
• It gives the protocol revenue on day one, at zero utilisation, before a single renter arrives.
• At current rates the yield on a deposit roughly covers the gas that same GPU spends proving it is alive. The network pays for its own heartbeat.

Principal returns in full on a voluntary retirement, minus the reaper bounty on a liveness expiry, and is forfeited to the insurance fund on a quorum revocation for fraud. Returns are credited to a pull-payment ledger rather than pushed, because pushing would let a provider whose address cannot receive MON block expire() forever and squat its fingerprint past the 72-hour rule.

08Reaching the hardware

This is where decentralised compute usually fails quietly. A datacenter card has a public IP; a 4090 in a spare room has a router with no inbound ports. A design that only works for the first is a cloud reseller with extra steps.

renter   publishes job spec (image, ssh key, ephemeral X25519 key) → relay
          commits specHash on chain when opening the job
agent    reads spec, starts the container, opens an outbound tunnel
          seals the endpoint to the renter's key, publishes the blob → relay
          commits endpointHash on chain with its signed acceptance
renter   fetches blob, checks keccak(blob) == endpointHash, decrypts locally, connects

Both hashes are on chain, so neither side can later claim a different spec was agreed or a different endpoint delivered. The relay is a content-addressed bulletin board: it can withhold, but it cannot lie, and anyone can run one. Three transports sit under the same flow — direct for public IPs, an outbound tunnel for machines behind NAT, and a fallback TCP relay. The sealed endpoint carries the SSH host key fingerprint so the renter pins it and no intermediary can interpose.

09Economics

Listings are priced in stablecoins. A provider quoting a dollar rate and being paid in a volatile asset is taking a trade it did not ask for, and the first drawdown empties the grid. $WRAITH does the jobs a stablecoin cannot: rewarding proven availability, rebating renters, buying capacity, and capturing fees.

Availability mining

Providers earn $WRAITH per proven online GPU-hour, weighted by class, paid only while attested and passing surprise re-challenges, capped per card, and multiplied by real completed jobs so idling never out-earns working. Accrual happens in the heartbeat transaction itself — one extra storage write on a transaction that was already happening, so there is no off-chain accumulator and no trusted publisher.

This is what makes the cold start survivable. On day one there is no demand, so a rational provider would not join. Availability mining pays them to be there while demand is found, and decays as real revenue arrives.

The loop

compute demand ─┬─▶ protocol fee (2.5%, USDC) ──┐
                   │                              │
                   └─▶ mint deposits (MON) staked ┤─▶ treasury ─▶ buy $WRAITH
                                  ~8.3% APR       │
licence sales ──────────────────────────────────┘
   (priced in WRAITH: buying capacity means buying the token)
                                                   │
  emissions ◀── availability mining · rebates ◀─┘
   (paid to the providers and renters who supply and consume compute)

Two of the three inflows do not depend on anyone renting anything: staking yield accrues on every locked deposit whether the grid is busy or idle, and licence sales are capacity bought forward. That is what lets the buyback begin on day one rather than waiting for utilisation the network does not yet have.

Supply

$WRAITH is a 1,000,000,000-supply ERC-20 already live on Monad. Of the founding position, 100M is committed to seeding the grid and the remainder is retained.

Buybacks convert usage into token demand. They are a mechanism, not a promise about price, and nothing in this paper is investment advice.

10For providers

Bringing a card onto the grid, in the order it happens:

1. Key — the agent generates a device key that stays on the machine and controls no money.
2. Scan — it reads the hardware fingerprint from the driver: UUID, serial, PCI location, VBIOS.
3. Prove — each attestor issues its own challenge; the card runs every one of them.
4. Enrol — the quorum's signatures plus the MON deposit mint the soul.
5. Stake and list — post collateral and publish a per-second rate.
6. Run — the agent heartbeats, accepts jobs, provisions containers and tears them down.

11Scale

Monad's throughput is what makes per-second settlement and frequent liveness proofs viable at all. Measured costs, at the gas price observed on mainnet — and noting that Monad charges the gas limit rather than gas used, so these are close to real rather than optimistic:

Heartbeats are the only cost that scales with fleet size rather than revenue, which makes them the number to watch: roughly 1 MON per GPU per year at two proofs a day once batched. Against a card earning tens of dollars a day that is noise — and it is roughly what the mint deposit's staking yield throws off, which is not a coincidence but the reason the deposit is sized where it is.

12Risks and honest limits

Read this section twice. Every item here is a real limitation, not a formality.

• Attestation proves the card existed at enrolment, not that it is dedicated to you now. A provider can oversubscribe one card across renters. Heartbeats prove liveness, not exclusivity. Surprise re-challenges during jobs and renter-side benchmarking are the answer, and are next on the roadmap rather than shipped.
• Nothing here makes a provider trustworthy inside the container. Someone with physical access can read what runs on their own machine. Confidential computing (H100 CC mode, SEV-SNP attestation) is the real answer and slots in as an additional attestation claim.
• Dispute rulings are human judgement. The chain enforces the ruling, not its fairness.
• Deposits sit in third-party staking code. Exposure is capped, the venue is swappable by governance, and an emergency exit moves everything to plain MON without a redeploy — but the risk is real and is disclosed rather than engineered away.
• The relay can withhold. It cannot lie, because every blob is addressed by a hash that also lives on chain. Run more than one.
• Unaudited. 89 contract tests with fuzzed invariants, a mainnet fork test and a full end-to-end run are not an audit. Treat mainnet as beta and cap what you put at risk.

13Roadmap

1. Correctness and deployment. The liveness rule, hardware-keyed collateral and the mint deposit are built and green. Next is deployment to Monad mainnet.
2. Usable at ten cards. Indexer, presence service, tunnelled access, a seed fleet, and this site as the front door.
3. The economy. Availability mining accrued on chain, renter rebates, WRAITH-priced licences, fee and float buybacks.
4. Worth trusting. Additional independent attestors with a strict-majority threshold, surprise re-challenges, compute-redeemable licences, multi-GPU hosts, and an audit.