AI Agent Interface (SIL v0.3): Direct machine-readable semantic layer for this commercial offer and sample report. SIL Layer for AI Agents: /monitoring/index.sil →
Commercial Offer · Sir Revizor Execution-Verified Verdicts · 24h Business-Day SLA SIL Layer: /monitoring/index.sil

Sir Revizor — Continuous Code Security Monitoring

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.

How Continuous Execution-Verified Monitoring Differs

Beyond Point-in-Time Audits

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.

Zero SAST Noise

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.

Zero Infrastructure Overhead

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.

What You Receive & How We Work

  • Full-Stack Daily Commit & PR Review: Continuous review of new commits and pull requests across your entire language stack with pinned commit SHAs.
  • Complete Execution-Verified Findings: Every reported defect includes a clear description, root-cause analysis, reproducible execution check (PoC trace with concrete before/after values), severity verdict, and patch recommendation.
  • Candidates Refuted by Execution: High-risk-looking static candidates that fail execution reproduction are explicitly logged as refuted so your engineers never waste hours re-investigating safe code.
  • Prompt Defect Alerts & Quiet-Month Reports: Immediate reports when a new defect is confirmed (plus daily "all clear" notes on request). Even in a quiet month with zero new defects, you receive a full engineering report: every commit examined, triggers fired and rejected by execution, re-tested fixes, and period coverage boundaries.
  • 24-Hour Triage SLA & Direct Founder Line: 24-hour business-day triage SLA with PoC confirmation on newly detected findings, plus a direct communication line to the technical founder (Telegram / Slack). Hard questions are documented and answered rigorously, never guessed.

Transparent Monthly Pricing

Founding-Client Rate (Month 1)
$2,000 / first month

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.

Standard Subscription (From Month 2)
$3,000 / month

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.

Sanitized Sample Technical Report ("1-of-N" Demo)

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.

1. Finding Passport

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.

2. Summary & Root Cause

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)
}

3. Reproducible PoC & Execution Trace

Local test execution command:
forge test --match-test test_ClaimAndCompound_PartialErasesUnclaimedRewards -vvv

  • Initial vault state: totalAssets = 100_000e18, totalShares = 100_000e18, reward index accRewardPerShare = 0.05e18 (50_000_000_000_000_000).
  • Actor Alice position: user.shares = 10_000e18, user.rewardDebt = 0. Accrued claimable reward pending = 500e18.
  • Alice executes: vault.claimAndCompound(200e18, 200e18) (compounding 200 out of 500 accrued reward tokens).
  • Target invariant: claimable_before == compounded_amount + claimable_after (500e18 == 200e18 + 300e18).
  • BEFORE execution: user.shares = 10_000.000000e18, user.rewardDebt = 0.000000e18, claimable_before (pending) = 500.000000e18.
  • AFTER calling claimAndCompound(200e18, 200e18): minted = 200.000000e18, user.shares = 10_200.000000e18, user.rewardDebt = (10_200e18 * 0.05e18) / 1e18 = 510.000000e18, claimable_after = 0.000000e18.
  • Measured discrepancy: 300.000000e18 reward tokens (60% of Alice's accrued yield) are permanently lost to the user in a single valid partial-compound transaction.

4. Candidates Refuted by Execution (Noise Filtered Out for Your Team)

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:

  • Refuted Candidate A (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).
  • Refuted Candidate B (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).

5. Fix Recommendation & Post-Fix Verification

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.

6. Summary of Remaining Candidates in Triage ("1-of-N" Rule)

  • [Candidate #2 — 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).
  • [Candidate #3 — 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 & Service Disclaimer

Operational Transparency & Liability Cap

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).