flow-vrf

Generates deterministic jury selections from VRF seeds using Fisher-Yates shuffle.

1|Updated Feb 8, 2026
One-click install
npx skills add https://github.com/leomanza/delibera.xyz --skill flow-vrf
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: flow-vrf
Source: https://github.com/leomanza/delibera.xyz/tree/main/.claude/skills/flow-vrf
Command: npx skills add https://github.com/leomanza/delibera.xyz --skill flow-vrf

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

Flow VRF jury selection eliminates biased or opaque leader/juror selection by producing verifiable randomness that can be audited.

Core Features & Use Cases

  • Provably fair jury selection: Requests randomness from Flow via a Cadence script invoking revertibleRandom<UInt64>(), then uses the VRF seed for deterministic selection.
  • Unbiased selection from a candidate pool: Applies a Fisher-Yates shuffle over the voter pool using the VRF seed as an LCG PRNG source.
  • On-chain logging support: Returns the selected jury alongside the VRF seed and a proof string suitable for on-chain logging.
  • Use case: When coordinating DAO deliberation, randomly and verifiably choose a subset of eligible voters as jurors for each deliberation round while keeping the selection method auditable.

Quick Start

Use the flow-vrf skill to select a jury by providing the candidate pool of NEAR account IDs, the desired jury size, and a deliberation ID, and receive the jury, VRF seed, and proof for verification.

Frequently Asked Questions about flow-vrf

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I select a DAO jury with provable randomness?

To select a DAO jury with provable randomness, provide a candidate pool of account IDs and desired jury size. The skill requests verifiable randomness from Flow, applies a Fisher-Yates shuffle, and returns the selected jury with a VRF seed and proof string for on-chain logging.

What is Flow VRF and how does it work for jury selection?

Flow VRF provides verifiable randomness by invoking `revertibleRandom<UInt64>()` via a Cadence script. This VRF seed drives a deterministic Fisher-Yates shuffle over a candidate pool, ensuring unbiased leader or juror selection that can be cryptographically audited.

Can I use FCL to get verifiable randomness for deterministic election?

Yes, you can use FCL to execute a Cadence script calling `revertibleRandom<UInt64>()` on Flow. This returns a VRF seed used as an LCG PRNG source to deterministically derive an unbiased, provably fair subset from your candidate pool.

How do I log a selected jury on-chain after a Fisher-Yates shuffle?

After deriving a jury via Fisher-Yates shuffle, the skill returns a VRF seed and a proof string alongside the selected accounts. You can use this proof string and seed for on-chain logging to keep the deliberation selection method fully auditable.

Does verifiable randomness jury selection work for multi-agent DAO governance?

Yes, verifiable randomness jury selection is designed for multi-agent DAO governance. It randomly and verifiably chooses a subset of eligible voters as jurors for each deliberation round while maintaining an auditable selection method.