Every day we pull the current state of your repository, pin the commit, scan changes across your entire language stack, triage what is new, verify by actual execution, and deliver actionable fix recommendations. Detection is not a verdict: only execution proves it.
A traditional one-off security audit is a snapshot of a single commit that expires the moment your team merges the next feature or refactoring PR. We monitor your live repository daily as your codebase evolves.
Standard static analyzers flood engineering teams with hundreds of raw warnings. We never dump scanner output on your developers: you receive investigation results confirmed by real execution, while false alarms are filtered out and documented as Refuted by Execution.
You install and maintain nothing in your CI/CD or production environment. We handle repository tracking, isolated execution harnesses, PoC construction, and fix re-verification externally.
First paid 30-day period on your agreed repository. You evaluate our execution-verified reporting quality on your live codebase, we verify mutual working fit, and you lock in the Standard $3,000/month rate forever.
Locked for Founding clients forever. Exact scope pricing (based on codebase size and commit activity) is fixed upfront in the agreement. Flexible renewal: auto-renew until cancelled or explicit monthly consent — your choice. Crypto payments supported with written confirmation for every payment.
Below is a complete, sanitized sample report (ExampleVault.sol) illustrating the exact structure, execution trace depth, refuted-candidate filtering, and patch verification delivered to clients.
| Repository / Commit | example-defi-protocol / commit a1b2c3d (branch: main) |
|---|---|
| Component / Function | contracts/vault/ExampleVault.sol — claimAndCompound(uint256 amount, uint256 minShares) |
| Defect Class | Reward Debt Accounting Desynchronization |
| Severity | Medium (no direct theft of principal deposits, but every partial compound permanently erases the user's uncompounded pending reward balance, locking those reward tokens inside the vault contract) |
| Verification Status | Confirmed via local execution harness (Foundry); mainnet and public testnets were NOT touched. |
The claimAndCompound function explicitly allows a user to reinvest a partial amount of their accrued rewards (amount <= pending) into newly minted vault shares. However, at the end of the function, user.rewardDebt is reset based on the user's full updated share balance as if the entire pending reward had been claimed or compounded. Consequently, the uncompounded remainder (pending - amount) is silently wiped from the user's claimable balance and permanently orphaned inside the contract.
Sanitized code snippet (contracts/vault/ExampleVault.sol, lines 142–153):
function claimAndCompound(uint256 amount, uint256 minShares) external nonReentrant returns (uint256 minted) {
UserInfo storage user = userInfo[msg.sender];
uint256 pending = (user.shares * accRewardPerShare) / 1e18 - user.rewardDebt;
require(amount <= pending, "ExampleVault: exceeds pending");
minted = _convertToShares(amount);
require(minted >= minShares, "ExampleVault: slippage");
totalShares += minted;
user.shares += minted;
user.rewardDebt = (user.shares * accRewardPerShare) / 1e18; // <-- BUG: overwrites full debt, erasing (pending - amount)
}
Local test execution command:
forge test --match-test test_ClaimAndCompound_PartialErasesUnclaimedRewards -vvv
totalAssets = 100_000e18, totalShares = 100_000e18, reward index accRewardPerShare = 0.05e18 (50_000_000_000_000_000).user.shares = 10_000e18, user.rewardDebt = 0. Accrued claimable reward pending = 500e18.vault.claimAndCompound(200e18, 200e18) (compounding 200 out of 500 accrued reward tokens).claimable_before == compounded_amount + claimable_after (500e18 == 200e18 + 300e18).user.shares = 10_000.000000e18, user.rewardDebt = 0.000000e18, claimable_before (pending) = 500.000000e18.claimAndCompound(200e18, 200e18): minted = 200.000000e18, user.shares = 10_200.000000e18, user.rewardDebt = (10_200e18 * 0.05e18) / 1e18 = 510.000000e18, claimable_after = 0.000000e18.Standard static analyzers flag several locations in this contract that look alarming on paper. We tested each candidate via actual execution and proved them safe so your engineers waste zero time triaging false positives:
ExampleVault.sol:98, rounding direction in _convertToShares on initial deposit): Static scanners flag a potential first-depositor inflation/donation attack resulting in zero-share mints. Execution testing against the constructor's virtual offset initialization (VIRTUAL_SHARES = 1e6 and VIRTUAL_ASSETS = 1e6 at line 44) proved that for any user deposit >= 1000 wei, an attacker donating up to 10_000e18 tokens suffers an immediate >99.99% capital loss. Verdict: SAFE (Refuted by execution).ExampleVault.sol:211, state update ordering in emergencyWithdraw): Static scanners flag asset.safeTransfer(msg.sender, assets) occurring prior to the lastHarvestBlock update as a reentrancy hazard. Execution testing with a malicious ERC-777 callback token confirmed that the function is guarded by nonReentrant and zeroes user.shares at line 206 before the external call; a stale lastHarvestBlock within the same transaction cannot be leveraged to extract extra funds or shares. Verdict: SAFE (Refuted by execution).
Deduct the uncompounded reward remainder (unpaid = pending - amount) from the newly calculated reward debt baseline (since user.shares increased, newBaseline = (user.shares * accRewardPerShare) / 1e18 is guaranteed to be strictly greater than pending and unpaid, preventing underflow):
totalShares += minted;
user.shares += minted;
- user.rewardDebt = (user.shares * accRewardPerShare) / 1e18;
+ uint256 unpaid = pending - amount;
+ uint256 newBaseline = (user.shares * accRewardPerShare) / 1e18;
+ user.rewardDebt = newBaseline - unpaid;
}
Post-fix test execution result: forge test --match-test test_ClaimAndCompound_PartialErasesUnclaimedRewards -vvv — PASS. After calling claimAndCompound(200e18, 200e18), user.rewardDebt updates to 210.000000e18, leaving claimable_after = 300.000000e18. The accounting invariant claimable_before == compounded_amount + claimable_after holds across 10,000 fuzz runs.
Router.sol]: residual non-zero ERC-20 allowance remains active on the routing adapter after a multi-hop swap experiences a partial fill on the secondary pool (Medium / Hardening).EpochDistributor.sol]: non-strict boundary check (block.timestamp == epochEnd) creates a single-block window where reward snapshotting and epoch counter increment can desynchronize (Low / State-transition drift).Straight Talk: The service currently operates directly through the individual founder while formal company registration is being completed, after which agreements transition to the corporate entity. Every payment receives a written confirmation. We do not invent fictitious client logos: we prove our value directly on your code.
Honest Disclaimer: Sir Revizor Continuous Code Security Monitoring is a systematic defect-detection and risk-reduction service, not a guarantee of absolute zero defects. Total contractual liability is capped at 3 months of subscription fees paid (full terms specified in the monitoring agreement).