Névé encodes every blob into fragments so the whole is recoverable from a fraction. Availability survives faults instead of assuming they won't happen.
Sweep across the fragments to destroy them. The blob rebuilds from whatever survives — until too few remain.
A blob is available if it can be retrieved. Névé makes that a measurable property rather than a promise from whoever stored it.
Each blob is erasure-coded into n fragments such that any k of them reconstruct the original. Data survives even when most fragments are missing or withheld.
Light nodes request a handful of random fragments. A few successful samples give overwhelming confidence the full blob is recoverable, so verification cost stays flat as blocks grow.
Every fragment ships with a polynomial-commitment opening, letting a node confirm the fragment belongs to the committed blob without downloading the rest of it.
Every parameter trades against another. Lower the recovery threshold and the blob survives more loss — but every node stores more copies of it. Move the sliders and watch the cost follow.
How finely the blob is split before distribution.
Share of fragments needed to rebuild the original blob.
Random fragments a light node pulls before accepting a block.
The hero animation and the attestation you sign below both follow the values you set here.
Confidence that a withheld blob is caught, by number of samples
Confidence is modelled as 1 − ts, where t is the recovery threshold and s the sample count — an illustrative approximation of sampling against a withholding proposer, not a security proof.
Retrievability is cheap to prove now and expensive to prove forever. Névé re-commits verified fragments across epochs into denser attestation layers.
Snow becomes névé becomes glacial ice. Old proofs compress into a single recursive commitment while the underlying data stays reconstructable on demand.
Two calls: submit data to the availability layer, then sample it at any past height to prove it was recoverable.
// submit a blob to the availability layer import { Neve } from "@neve/sdk"; const client = new Neve({ endpoint: "https://rpc.testnet.neve.xyz" }); const receipt = await client.submitBlob({ namespace: "0x6e657665a1", data: payload, // raw bytes redundancy:{ n: 128, k: 43 }, // recover from ~33% }); // later: prove it was available at that height const proof = await client.sampleAvailability(receipt.height, { samples: 16, }); console.log(proof.recoverable); // true
This is what a light node actually does: sample a blob, then sign a statement vouching that it was recoverable. Aggregated across nodes, those signatures are the availability proof for a block. Here it runs locally — a real, verifiable signature that never touches funds.
Needs a browser wallet (e.g. MetaMask) and the page opened directly in your browser. Extensions can't inject into an embedded preview frame, so use the button on the right to walk through it here.