How Node Hour works

1 · Overview

Three layers. Two are live; the third has its first real piece.

• Measure. Provider rate cards are read through public APIs and normalised into one market per GPU class. Live. See the index page.
• Offchain trading. A terminal with a book, a tape, a chart and an order ticket, priced off the index. Live. Play money only.
• Settle and deliver. Beta. You can ask for real GPU-hours from the terminal (§8); we rent a real machine, hand you SSH and publish a proof of delivery on Ethereum (§10). An escrow contract for on-chain payment is deployed on mainnet with beta limits (§9). Automated self-serve checkout is not built yet.

The site itself never sends a transaction from your wallet and takes custody of nothing. The only thing that can hold funds is the escrow contract in §9, and only if you pay into it yourself.

2 · The index

Each market carries one measured number: the lowest on-demand price a provider publishes for a single card of that class, in dollars per GPU-hour.

It is refreshed on every page load, cached 60 seconds at the edge, and served stale for up to ten minutes if the provider is unreachable — a stale read is labelled stale rather than silently passed off as fresh. The terminal re-reads it every two minutes.

The market list is fixed and does not shrink. A provider stops quoting a class the moment it has no free cards — RTX 4090 and L40S drop out of the response several times an hour — and when that happens the market keeps its last measured price, stamped with the time it was measured and marked stale. It is never removed, and the aggregate figures on the front page are computed over the whole fixed roster, so the number of markets, the lowest print and the spread do not move because one vendor sold out. A class with no measurement at all reads no quote rather than borrowing a number.

The full unnormalised provider response is published at /api/prices and rendered on the index page, including the SKUs we do not trade. The limits of the current construction — single source, unweighted, no history, floor rather than mid — are listed there too.

3 · Markets

One market per GPU class, quoted in USDC per GPU-hour: B200, H200, H100, A100, L40S, RTX 4090.

Vendors sell SKUs rather than classes. H100 SXM, H100 NVL and H100 PCIe are three products with three prices; each market maps to an ordered list of SKU patterns and takes the first that is quoted, so a class always resolves the same way. The SKU actually used is shown in the terminal header and on the index page.

Markets are long only. You can sell only what you hold, so a position is always backed by hours you bought. There is no shorting and no leverage — both require a counterparty who can lose, and there is no counterparty here.

4 · Test account

The terminal opens with $10,000 in play money and you can trade immediately — no wallet, no deposit, no faucet, no claim. The number is written into your browser's local storage.

Connecting a wallet moves that account under your address and carries an in-progress guest run across, so nothing you did before connecting is lost. It is also what will put you on the season table later.

Consequences worth knowing: the account lives on one browser on one device, clearing site data erases it, and it is not visible to us or to anyone else. Reset is a button on the Account card.

5 · Wallet session

Node Hour uses an injected EIP-1193 wallet — MetaMask, Rabby, Phantom's EVM side, anything that puts window.ethereum on the page.

Connecting does two things: it reads your address, and it asks you to sign one message with personal_sign. That signature is an off-chain proof that you control the address. It is not a transaction, it costs no gas, it grants no allowance, and it cannot move a token. The exact text you are asked to sign says so.

The site does not care which network you are on, because nothing is read from or written to a chain. The mainnet notice exists only because $NHOUR lives there.

6 · How fills work

A market order fills instantly at the current simulated mark, in full. There is no queue, no partial fill, no slippage against the displayed book and no rejection except for insufficient test balance or hours.

That is a simplification, and it flatters you: a real fill of any size walks the book and gets a worse average. Treat PnL here as directionally useful and nothing more.

7 · Fees

A 0.40% fee is charged on both sides of every offchain trade and deducted from your test balance. It is shown so the arithmetic of a strategy is realistic.

It is charged to nothing. No fee is collected, by anyone, anywhere. The figure exists to make the simulation honest about costs, not because a protocol is earning.

8 · Redeem real GPU-hours

The Account card in the terminal has a Redeem GPU-h button. Pick a class and a number of hours, leave a Telegram handle or an email, and send. The request goes to https://api.nodehour.io/v1/redeem-requests together with the index price you saw at that moment.

Nothing is charged by that form and no machine starts automatically. During the beta our support contacts you, agrees the terms (price is the live index for the class), and arranges access. Delivery is a real cloud GPU rented through the vendor's public API, with your SSH key on it.

Every delivered order gets a delivery log — GPU UUID, driver, nvidia-smi dump, request → boot → SSH timestamps, workload result — and the SHA-256 of that log is written on-chain (§10).

9 · Escrow contract

NodeHourRedeem on Ethereum mainnet, UUPS upgradeable proxy 0xD947da92d0DC975009d8ca0E5d4f773D3A2742eF (implementation v1 0xCF17B48CCdf143133BB56CCda0B36f83E1B73Fb4). Source verified on Etherscan.

• pay(orderId) — you pay ETH for an order issued by our backend. The ETH stays escrowed in the contract.
• deliver(orderId, proofHash, uri) — our publisher wallet records the hash of the delivery log. Only after that can the order's ETH be withdrawn to the treasury.
• refund(orderId) — an order that could not be delivered is returned to the payer from the same contract.

Beta limits, readable on Etherscan: at most 0.02 ETH per order, at most 0.3 ETH held in escrow in total, payments only from allowlisted wallets. Owner and treasury 0x6cC06dDFad7849F9Cc0Ea965aC9924b042c4c3b5, publisher 0x83a973A2C9946f5082dE7746e051c83cfBcf5242 (records proofs, has no access to funds).

Honest limits: the contract is upgradeable by its owner, which means you trust the owner not to change the rules mid-order — that is why limits are small and every upgrade will be announced with its transaction. The contract has not been externally audited.

10 · Proof of delivery

A rate card says what a vendor wants for an hour. A delivery log says what an hour actually delivered. Each log is published as canonical JSON; its SHA-256 is recorded in the escrow contract with deliver(), so a log cannot be edited after the fact without the hash breaking.

Order #0, 2 Oct 2026 — our own first hour, paid by us off-chain: one H100 SXM 80GB HBM3 rented on vast.ai for $1.7356/h while the Node Hour H100 index read $2.69/h; requested → running in 174 s; 3,622 s on the card. Log: /proofs/20261002T113816Z/log.json, summary: SUMMARY.md, proof tx 0xf6e6ff28ff96ebc6f56addb76f79fdda76b4f974e77dc258bfd673f08d6676ad. The controller lost its SSH session before reading the hour's own throughput line, so the log records the hour without a TFLOPS figure — we say so instead of filling it in.

Order #1, 2 Oct 2026 — 15-minute verification run on the same physical GPU (UUID GPU-c0464b35-0f50-72f7-dbf9-13b22b54d2b9): 681.7 TFLOPS bf16 sustained (dense 8192² matmul, per-minute 680.6–683.3), 100% utilization at ~698 W, requested → SSH in 25 s, → $2.55 per effective PFLOP-hour at $1.7356/h. Log: /proofs/20261002T131716Z/log.json, summary: SUMMARY.md, proof tx 0x7d13bb67b8cbfba20a187955bb173dc234de31b06f496c3ac490a463a600adee.

Order ids 0–999 are reserved for our own measurement runs; customer orders start at 1000.

Verify it yourself: download the log, run sha256sum log.json, and compare with the proofHash in the Delivered event of the contract.

What a log proves and what it does not: it proves which GPU the vendor's machine reported (UUID, driver), how long it took to get it, what our public workload measured, and that the log was not changed after it was anchored. It does not prove that a third-party host's nvidia-smi is honest; where a host offers NVIDIA hardware attestation the log includes it, where it does not the log says so.

11 · Index history

Since 2 Oct 2026, 11:33:49 UTC the full /api/prices answer is stored every five minutes, untouched, failed reads included. No backfill: the series starts where it starts. Charts, volatility and anything a contract would settle on will be computed from this table.

12 · $NHOUR

$NHOUR is an ERC-20 on Ethereum. It pays for seasons and prizes on the terminal and votes on which GPU classes get a market. That is the complete list of what it does.

It is not a claim on revenue, a share, a governance right over anything but market listings, or a promise of return. There is no revenue to divide. Any protocol income and every buyback will be published with a link to the transaction on the token page, or not claimed at all.

13 · Risk and honesty

Nothing here is investment advice, and a offchain PnL is not evidence that a strategy works — fills are idealised, the book is invented and the sample is short.

Redeem is a beta run by hand: a request is not an order until support confirms it, and on-chain payment is by allowlist with small limits.

The index is a real measurement of one vendor's asking price. It is not a benchmark, not audited, and not a substitute for a quote from a provider you are about to buy from.

If you find a number on this site whose label does not match what it is, that is a bug and we want to hear about it. It is the only kind of bug here that matters.

14 · Glossary

• GPU·h — one hour of one GPU of a given class. The unit everything is quoted in.
• Index — the measured on-demand price for a class. Cyan, everywhere.
• Mark — the simulated last traded price. Amber. Drifts around the index.
• Basis — how far the mark sits from the index, in percent. The only number tying the simulation to reality.
• SKU — the product a vendor actually sells, e.g. H100 NVL, as opposed to the class H100.
• Offchain — simulated. Not real money, not a real order, not a real fill.
• Redeem — turning a request for GPU-hours into a real machine you can SSH into.
• Proof of delivery — the SHA-256 of a delivery log, recorded on-chain so the log cannot be rewritten.