Nuvex Network

Verifiable compute on Solana

Nuvex checks proofs inside Solana programs and hands the result to your callback. VRF is live in the programs today. A configured indexer can copy those accounts for the console. Data, compute, and inference jobs are planned.

Nuvex ▾

Protocol

Overview
Requests
Nodes
Callbacks

Network

Stake
Heartbeat
Slashing

Jobs

VRF
Price feeds
Compute

VRF request

Illustration · not chain data

Verifiedcallback executed

job_type = VRFproof 80 Boutput 64 B

OpenAssignedProvedVerifiedCallback

Node 01stake 92%Fulfilled
Node 02stake 78%Eligible
Node 03stake 64%Eligible

Verifiable infrastructure for programs that need proof, not promises

Node heartbeat···

Illustration · not chain data

Verifiable randomness

Live

A VRF request is fulfilled with an ECVRF proof that the verification program checks before the output is written.

Oracle data

In development

A public price median is available from the API when enough sources are fresh. It is not written on-chain. Arbitrary data jobs are still not designed.

Verifiable compute

Planned

Off-chain execution with a committed result is a reserved job type. No compute job runs today.

AI inference

Planned

Inference requests share the same request lifecycle. How to verify a model output is an open research question.

Open requestOPEN

job_type: VRF
requester: your program
input: 32-byte seed
callback: consumer program
max_fee: recorded, not charged

Illustration · not chain data

Three programs

oracle-core holds requests, oracle-registry holds nodes and stake, and verification checks proofs. Each is an Anchor program.

ProgramsAnchor 1.2

oracle-corerequests, callbacksLive
oracle-registrynodes, stake, slashLive
verificationECVRF proofsLive

Account derivation

The Rust and TypeScript SDKs derive every program address and can prove a VRF output locally. They do not send transactions yet.

request.ts

// TypeScript SDK
import { requestPda } from "@nuvex/sdk";
 
const [request] = requestPda(
  coreProgramId, requester, requestId,
);

Operator process

The node binary exposes health and metrics. It does not load a VRF key or submit a fulfilment.

nuvex-oracle-nodeHealth only

/healthok
/metricsexposed
VRF keynot loaded
fulfilmentsnot submitted

Read model

The indexer copies observed request, node, and proof accounts. The API and console can list them. That list is not chain authority.

terminal

$ nuvex network
NUVEX_API_URL is unset
 
$ nuvex --help
node  request  registry  staking  network

Rust SDK

PDA helpers for every account and a prove_vrf function that keeps the secret with the caller.

prove.rs

// Rust SDK, secret stays local
let proof = nuvex_sdk::prove_vrf(
    &secret, &request, JobType::Vrf, &input,
)?;
 
// proof.proof: [u8; 80], proof.output: [u8; 64]

TypeScript SDK

The same derivations for web clients. Submitting a request throws until transactions are wired.

request.ts

// TypeScript SDK
import { requestPda } from "@nuvex/sdk";
 
const [request] = requestPda(
  coreProgramId, requester, requestId,
);

Command line

network reads the configured API and refuses to invent status if the URL is unset. The other operational commands still refuse to send.

terminal

$ nuvex network
NUVEX_API_URL is unset
 
$ nuvex --help
node  request  registry  staking  network

Proofs checked in a program

The output is written only after the verification program accepts the ECVRF proof for that exact request. A node cannot swap in a different output after the fact.

VerificationRFC 9381

COMMITTEDproof submitted with the output
VERIFIEDECVRF checked by the program
FINALIZED64-byte output written
EXECUTEDcallback ran, no accounts passed

Illustration · not chain data

Stake before fulfilment

Nodes lock the configured stake and heartbeat inside a window. A node that misbehaves can be slashed. A minimum of zero offers no resistance, and the docs say so.

Stake and heartbeatper node

Minimum stake

configured

Heartbeat window

configured

Registered before request

required

Slash

available

Register

Join registry
Lock stake
Heartbeat

Register a node

A node key joins the registry, locks stake, and starts heartbeating before it can fulfil.

Verify

proof

80 B

output

64 B

Verify the proof

RFC 9381 ECVRF on Ed25519. 80-byte proof in, 64-byte output out, all inside the program.

Callback

accounts passed0

EXECUTED

Deliver the output

The callback program receives the output and no accounts, so it cannot be handed extra authority.

Protocol README

Eligibility

“A node fulfills only when it is active, its stake meets the configured minimum, its heartbeat is inside the configured window, and the key was registered before the request.”

Open source

Programs, SDKs, CLI, and node live in one public repository under Apache-2.0.

Not audited yet

No independent audit has been performed. The VRF crate has no published audit either.

Solana programs

Byte ECVRF proof

Byte VRF output

Job families live

Building verifiable compute on Solana

Nuvex accepts a job, checks the proof inside a program, and hands the result to your callback. Randomness is live in the programs. A configured read API can list those accounts. Data, computation, and inference come next.

Verifiable infrastructure for programs that need proof, not promises

Verifiable randomness

Oracle data

Verifiable compute

AI inference

A loot drop where every player can re-check the roll against the proof

A lottery draw that settles in a callback, with the proof kept on the request

Fair allowlist ordering without a trusted party running the shuffle

A program that consumes a price, once a price verifier exists

An agent job whose off-chain work is verified, not merely submitted

Open a request

An eligible node fulfils

Proof verified, callback runs

Three programs

Account derivation

Operator process

Read model

Rust SDK

TypeScript SDK

Command line

Proofs checked in a program

Stake before fulfilment

Register a node

Verify the proof

Deliver the output

Nuvex accepts a job, checks the proof inside a program, and hands the result to your callback. Randomness is live in the programs. A configured read API can list those accounts. Data, computation, and inference come next.

Verifiable compute, starting with randomness

Everything a program needs to trust an off-chain result

Verifiable infrastructure for programs that need proof, not promises

Verifiable randomness

Oracle data

Verifiable compute

AI inference

What you could build with verifiable randomness

A loot drop where every player can re-check the roll against the proof

One request, checked end to end

Open a request

An eligible node fulfils

Proof verified, callback runs

Protocol surfaces built for Solana programs

Three programs

Account derivation

Operator process

Read model

A toolkit for every side of the protocol

Rust SDK

TypeScript SDK

Command line

Reasons to verify on-chain

Proofs checked in a program

Stake before fulfilment

Register a node

Verify the proof

Deliver the output

Built on open tools and standards

What the code says about itself

Nuvex accepts a job, checks the proof inside a program, and hands the result to your callback. Randomness is live in the programs. A configured read API can list those accounts. Data, computation, and inference come next.

Verifiable compute on Solana