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.
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:
- Value leaving to an address that is not the strategy target
- An approval granted to anything but the target, especially unlimited
- A call into a contract deployed within the last few days
- Delegatecall anywhere in the trace
- A target whose bytecode does not match verified source
- A price floor set loose enough to be sandwiched to nothing
- Share price falling as a direct result of the call
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).