Behavioral State Analysis

Token Budget Rules

Follow these strictly to avoid context exhaustion:

1. Be terse. Use bullet points and tables, not prose. No filler sentences.
2. Smart scope first. Classify the contract type in Phase 1, then run ONLY relevant engines in Phase 2 (see engine selection matrix below).
3. Tiered output depth:
   • Critical/High findings → full detail + PoC code
   • Medium findings → root cause + exploit scenario (no PoC)
   • Low/Info findings → one-line description only
4. No redundant analysis. If a dimension has no attack surface (e.g., no value flows = skip ETE), say "N/A" and move on.
5. Cap Phase 1 output to ≤30 lines per contract. List invariants and states, skip verbose specification documents.
6. PoC generation only for Critical and High severity findings. For others, describe the exploit path in ≤3 steps.
7. Combine phases in output — don't repeat findings across phases. Each finding appears once with all metadata inline.

Pipeline

Phase 1: Behavioral Decomposition (keep brief)

Extract intent from code and docs. Output per contract:

Contract: <Name>
Type: <DeFi/Token/Governance/NFT/Utility/Proxy>
States: [list]
Key Invariants (≤5):
  - <invariant>
Privileged Roles: [list]
Value Entry/Exit Points: [list or "none"]

Then select engines:

Lite = check only the top-priority item for that engine (see below).

Phase 2: Threat Modeling (selected engines only)

Run only the engines selected above. For each engine, analyze in this priority order — stop if contract surface is exhausted:

Economic Threat Engine (ETE):

1. Value flow tracing — where can value enter/leave? Any sinks or circular flows?
2. Economic invariant verification — does deposits == withdrawals + balance hold?
3. Incentive analysis — any rational actor exploits (MEV, sandwich, griefing)?

Access Control Threat Engine (ACTE):

1. Unprotected privileged functions — any admin/owner actions callable by anyone?
2. Role escalation paths — can User → [actions] → Admin?
3. msg.sender vs tx.origin confusion; signature replay

State Integrity Threat Engine (SITE):

1. Non-atomic state updates — partial updates before external calls?
2. Sequence vulnerabilities — initialization bypass, unexpected call ordering?
3. Cross-contract stale data or reentrancy vectors

Lite mode = run only item #1 from that engine's list.

Phase 3: Exploit Verification

For each hypothesis from Phase 2:

• Build attack sequence (≤5 steps)
• For Critical/High: generate minimal Foundry/Hardhat PoC (keep code short — test the specific vuln, not a full test suite)
• Quantify impact: Critical (all funds/system) | High (significant loss/privesc) | Medium (griefing/DOS) | Low (info/best practice)

Phase 4: Score & Prioritize

Score: Confidence = (Evidence × Feasibility × Impact) / FP_Rate

Impact: 5=total loss, 4=partial loss, 3=griefing, 2=info leak, 1=best practice FP_Rate: 0.05 (known pattern) → 0.15 (moderate) → 0.40 (weak) → 0.60 (heuristic)

Prioritization: Report findings ≥10% confidence. Never suppress Impact ≥4.

Finding Format (use for every finding)

### [F-N] Title
Severity: Critical|High|Medium|Low  |  Confidence: X%
Location: contract.sol#L10-L25, functionName()
Root Cause: <1-2 sentences>
Exploit: <numbered steps, ≤5>
Impact: <1 sentence with quantified risk>
Fix: <code diff or 1-2 sentence recommendation>
PoC: <only for Critical/High — minimal test code>

Advanced Checks (run only if relevant to contract type)

• Cross-contract: Map external call chains A→B→C, test transitive trust
• Time-based: block.timestamp manipulation, expired signatures, replay
• Upgradeable: Storage collisions, re-initialization, migration atomicity

Mindset

• "Standard function" → can behave non-standardly in context
• "Admin is trusted" → model admin compromise, check excessive powers
• "Known pattern" → novel interactions in specific contexts
• "Small value" → compounds; griefing scales
• "Trusted external contract" → trust boundaries shift; verify actual code