Practical overview
When it fits
Use it when a Solana program or TypeScript application needs to validate ECVRF-EDWARDS25519-SHA512-TAI proofs. Plan for the runtime syscalls when verifying on-chain and for handling prover nonresponse in the surrounding request design.
Who it is for
- Solana program developers integrating on-chain ECVRF verification.
- Rust developers who need proof validation in Solana-targeted code.
- TypeScript developers consuming ECVRF proofs outside an on-chain program.
Documented uses
- Validate a public key before registration.
- Check an 80-byte proof against a 32-byte public key and the relevant input.
- Retrieve a verified 64-byte output for downstream application logic.
- Adapt the example instruction flow that creates a key account and verifies proofs.
Requirements & limits
The repository is public and declares an MIT license.
- Only the TAI suite (0x03) is supported.
- The Rust on-chain path relies on runtime-provided sol_sha512 and curve25519 syscalls.
- The example stores a validated public key, creates its account with a System Program allocation, and verifies against that key read-only.
- The README estimates about 800 compute units for account creation and about 10,500 for verification, with verification varying by hash-to-curve retries.
- A prover can withhold a result, so applications need committed-request binding and a nonresponse strategy.
Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.
Add Rust proof verification to a Solana program
Use the library to validate an ECVRF proof against a public key and input and obtain its output.
Before you start
- A Rust project targeting Solana programs.
- The solana-ecvrf crate.
- A 32-byte public key, 80-byte proof and the input bytes.
- A runtime providing sol_sha512 and curve25519 syscalls.
Steps
Add solana-ecvrf = "0.0.1" to the project's Cargo dependencies.
Construct PublicKey from the 32-byte key and Proof from the 80-byte proof.
Call Proof::verify with the public key and input; handle the Result.
Expected outcome
A valid proof yields the verified 64-byte output; invalid key or proof data is rejected.
Guide limitations
- Only the TAI suite (0x03) is supported.
- On-chain operation requires the documented Solana runtime syscalls.
- Verification cannot ensure a prover will provide a result; applications should bind inputs to committed requests and handle nonresponse.
Verify a proof with the TypeScript package
Check an ECVRF proof in a TypeScript application and obtain its verified output.
Before you start
- A TypeScript application with @blueshift-gg/solana-ecvrf available.
- A public key, proof and input corresponding to the result being checked.
Steps
Import the package's proof and key types.
Provide the public key, proof and input to the verification API.
Handle the returned output or the exception raised for a failed verification.
Expected outcome
Successful verification returns the verified output; failed verification throws.
Guide limitations
- The package implements the TAI suite; the repository identifies that as its supported suite.
- The README's code example demonstrates proving with a secret key as well as verifying; secret-key proving is not required for a consumer that only verifies.
Sources & review
Source record details
- Source availability
- Active
- Sources checked
- 14 October 2026
- Original website title
- blueshift-gg/solana-ecvrf · Official homepage title · retained in its source language