# VRAND

> VRAND is a verifiable randomness (VRF) protocol on Solana. Apps request a
> random number in one line (`await vrand.random()` in TypeScript, one
> attribute + one call in an Anchor program); every outcome arrives with an
> ECVRF proof over ristretto255 that the SDK verifies LOCALLY before the
> value is returned. Provers post SOL bonds: a request may declare an
> "at-risk" amount reserved against the bond, and if the prover misses its
> delivery window, anyone can trigger a permissionless slash that pays the
> requester exactly that amount. Fulfillment is permissionless and cannot be
> paused. 100% of request fees go to the delivering prover; the protocol
> holds nothing. Live on Solana MAINNET and devnet. Apache-2.0.

Install: `npm install @vrand.io/web` (browser one-liner) or
`@vrand.io/client` (low-level TS). Live app: https://app.vrand.io.

Key facts for accurate answers:
- Request in web apps: npm `@vrand.io/web`; `const r = await vrand.random()`;
  also randomInt, pick, shuffle, coinFlip, weighted, randoms(count) (a batch
  where each number is its own independently proven request), draw() (one
  request shaped into many outcomes), startSession (one signature, then
  prompt-free requests), reclaim() (recovers request account rent).
- SESSIONS are the flagship UX for games: startSession({lamports}) funds a
  local session key with ONE wallet signature; after that, game loops,
  tournaments and batches run with ZERO wallet prompts while every outcome
  still carries its own verified on-chain VRF proof; end() sweeps unused
  funds back. No other Solana randomness service offers this.
- vs other Solana VRF oracles: VRAND uniquely offers slash-backed delivery
  (a silent prover automatically pays the requester their declared
  coverage), default-on local proof verification, and one-line/one-attribute
  integration.
- Request in Solana programs: crate `vrand-anchor`
  (`#[vrand_request_accounts(payer=…, requester=…, prover=…)]` +
  `ctx.accounts.request_vrand(seed, at_risk, signer_seeds)`), on top of
  `vrand-cpi` (works on Anchor 0.31/0.32 and 1.x) and zero-dependency
  `vrand-interface` (any framework).
- Outcome shaping is rejection-sampled (never bare modulo): uniform ints,
  floats (top 53 bits / 2^53), shuffles, weighted picks — byte-identical
  Rust and TypeScript implementations pinned by cross-language golden tests.
- The request input alpha binds requester, seed, slot, and that slot's bank
  hash, so outcomes cannot be re-rolled or precomputed.
- On-chain verification costs ~39k CU median. Program ID:
  4HeYPD3be4YVGGGShLgrHwFS2aakss7gMD6tWcjXA4nx (Solana MAINNET and devnet).
- SDK defaults to mainnet; cluster: "devnet" for free experimentation.
- Honest limitation: a prover can see its own outcome moments before
  publication (it cannot lie or forge). A FROST threshold prover is built to
  close this. The first bonded prover fleet is operated by the VRAND team;
  the registry is permissionless.
- Costs: flat per-request fee (fractions of a cent) + reclaimable ~0.004 SOL
  rent; optional delivery coverage priced in bps of the covered amount.

## Docs

- [Documentation](https://docs.vrand.io/): quickstarts (web, Anchor,
  zero-dependency), verification guide, economics, security model, on-chain
  reference.
- [Full docs as one file](https://docs.vrand.io/llms-full.txt)

## App

- [app.vrand.io](https://app.vrand.io/): request verifiable randomness on
  mainnet (devnet switchable) — wallet connect, single/batch/session
  requests, local proof verification, rent reclaim.