Recurve Docs
Website GitHub Open app

Protocol

Watchers

A staked network that replays proposed calldata before capital moves. Approving a drain is what the stake is for.

Eligibility

stake(uint256 amount)   // approve the registry for $RECURVE first

Stake $RECURVE. From the moment the stake reaches minStake — at it, not above it — the watcher is active and can cast verdicts. There is no reputation score and no allowlist; the stake is the entire credential. The minimum is about $20 of $RECURVE, fixed in tokens at the market price when staking opens; minStake() returns the figure in force. The registry owner can change it with setParameters, and a watcher left under a raised minimum fails castVerdict until they top up.

Verdicts are final

castVerdict(bytes32 proposalId, Verdict verdict)   // Verdict: None = 0, Approve = 1, Block = 2

One verdict per proposal per watcher. The contract rejects a second with AlreadyVoted, so simulate before you call it. There is no verdict window: the registry knows nothing about governors, so verdicts are accepted on any 32-byte id at any time, before a proposal exists or after it executed. blockCount(id) is what the governor reads at execute; approversOf and blockersOf list who ruled which way.

Pass Approve or Block

Verdict.None is not rejected. It is recorded as a block and, because it leaves the "already voted" mark unset, can be repeated — one active watcher can push blockCount past the threshold on their own. The app only ever sends 1 or 2; the SDK's castVerdict passes through whatever you give it, so pass Verdict.Approve or Verdict.Block, never None.

What to look for

Fork state at the proposal's block, execute the calldata against the target with the vault funded, and read the diff rather than the intent. Worth a block:

None of these prove malice. All of them justify a block, because a block costs nothing and a wrong approval costs everything. For a fund running PortfolioStrategy the surface is small: the target is the strategy, the call is buy, sell, returnToVault or setWeights, and the number to check is the floor written into the calldata. The step-by-step is on the watcher skill.

Economics

The contracts implement one economic mechanism: slashing. A conviction takes 100% of every approver's stake and burns it. Nothing pays watchers for being right — there is no fee share, no bounty and no per-round reward in the registry or the governor. If that changes it will be a new contract, and this page will say so.

convict(bytes32 proposalId)   // registry.governor only

Conviction is a call on the registry that only its governor address may make. It marks the proposal convicted, zeroes every approver's stake (and any pending unstake), sends the total to 0x000000000000000000000000000000000000dEaD, and emits Convicted(id, approvers, burned). Blockers and abstainers are untouched. The scripted deployment points registry.governor at the fund's RecurveGovernor, which has no function that calls convict — so today a conviction requires the registry owner to setGovernor to a key that can. What counts as convictable is not defined on chain.

Exiting

requestUnstake(uint256 amount)   // starts the delay; 7 days on the scripted deployment
unstake()                        // after the delay

requestUnstake records an amount and a timestamp; a second request overwrites both and restarts the clock. The stake itself does not move: the watcher stays active, keeps voting with the full stake, and stays slashable throughout, so approving a malicious call and heading for the door does not outrun a conviction. unstake pays out after unstakeDelay — the value current at that moment, since the owner can change it — and reverts UnstakeNotReady before, NoPendingUnstake if nothing is requested or a conviction cleared it. The app requests the whole stake; the SDK has no unstake method (use registryAbi with viem directly).