Weasel Simplify

Weasel Simplify

Expert Solidity code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality.

When to Activate

• Developer wants to clean up code
• User asks to simplify or refactor
• User wants to improve readability
• After writing new code that could be cleaner

Two Modes

Developer Mode (Default)

User wants to modify their codebase for maintainability.

• Edit actual source files
• Run tests after changes
• Commit simplified code

Auditor Mode

User wants to understand complex code during audit.

• Create scratch/mental simplification for analysis
• NEVER modify files being audited
• Output simplified version to terminal or scratch file
• Original code stays untouched

Detection: If in audit context (weasel-analyzer was used, or user mentions "audit"), default to Auditor Mode.

When NOT to Use

• Unfamiliar codebase - Understand first (→ weasel-overview)
• Security-critical changes - If unsure about a pattern's purpose, don't touch it
• No tests available (Developer Mode only) - Can't verify behavior without tests

Core Principles

1. Preserve Functionality

Never change what the code does - only how it's written. All features, outputs, and behaviors must remain identical.

2. Security First

Never simplify in a way that introduces vulnerabilities:

• Don't remove reentrancy guards for "simplicity"
• Don't combine checks in ways that could be bypassed
• Don't remove access control for fewer lines
• Don't reorder CEI pattern

3. Clarity Over Brevity

Readable code > compact code:

• Avoid nested ternaries
• Use meaningful variable names
• Keep functions focused

4. Gas Aware

Don't "simplify" into more expensive code. Preserve:

• Storage caching patterns
• Unchecked blocks where safe
• Calldata over memory for read-only params

Workflow

Developer Mode

1. Understand first - Read the code, understand WHY it's written this way
2. Scope - What to simplify? (specific function, file, or recent changes)
3. Check tests exist - If no tests, warn user before proceeding
4. Analyze - Find complexity without touching security patterns
5. Simplify - Apply transformations via Edit tool
6. Test - Run tests to verify behavior preserved
7. Report - Summarize changes made

Auditor Mode

1. Understand first - Read the code and surrounding context
2. Scope - What to simplify for analysis?
3. Analyze - Identify complexity that obscures logic
4. Output simplified version - Show in terminal or create scratch file
5. DO NOT edit original files
6. Note - "This is a simplified view for analysis. Original code unchanged."

Key Simplification Patterns

Pattern 1: Flatten Nesting → Early Returns

// Before: Deep nesting hides logic
function withdraw(uint256 amount) external {
    if (amount > 0) {
        if (balances[msg.sender] >= amount) {
            if (!paused) {
                balances[msg.sender] -= amount;
                payable(msg.sender).transfer(amount);
            }
        }
    }
}

// After: Guards at top, happy path clear
function withdraw(uint256 amount) external {
    if (amount == 0) revert ZeroAmount();
    if (balances[msg.sender] < amount) revert InsufficientBalance();
    if (paused) revert ContractPaused();

    balances[msg.sender] -= amount;
    payable(msg.sender).transfer(amount);
}

Pattern 2: Extract Repeated Logic → Modifiers

// Before: Same checks in multiple functions
function deposit() external payable {
    require(msg.value > 0, "Zero");
    require(!paused, "Paused");
    // ...
}
function withdraw(uint256 amt) external {
    require(amt > 0, "Zero");
    require(!paused, "Paused");
    // ...
}

// After: DRY with modifiers
modifier whenNotPaused() {
    if (paused) revert ContractPaused();
    _;
}
modifier nonZero(uint256 value) {
    if (value == 0) revert ZeroValue();
    _;
}

function deposit() external payable whenNotPaused nonZero(msg.value) { ... }
function withdraw(uint256 amt) external whenNotPaused nonZero(amt) { ... }

Pattern 3: Name Complex Conditions

// Before: Hard to read
if (amount > 0 && amount <= max && !blocked[msg.sender] && block.timestamp >= start) { ... }

// After: Self-documenting
bool isValidAmount = amount > 0 && amount <= max;
bool isAllowedUser = !blocked[msg.sender];
bool hasStarted = block.timestamp >= start;

if (isValidAmount && isAllowedUser && hasStarted) { ... }

Other Opportunities

• Remove dead/commented code
• Replace require strings with custom errors (gas savings)
• Decompose long functions
• Improve variable/function names
• Remove redundant initializations (uint256 x = 0 → uint256 x)

What NOT to Simplify

Security patterns - preserve even if "verbose":

// KEEP: Reentrancy guard
function withdraw() external nonReentrant { ... }

// KEEP: CEI order (Checks-Effects-Interactions)
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;           // Effect BEFORE
(bool ok,) = msg.sender.call{value: amount}("");  // Interaction
require(ok);

// KEEP: Explicit type casts
uint128 small = uint128(bigNumber);  // Don't hide conversions

// KEEP: Unchecked blocks
unchecked { ++i; }  // Don't "simplify" to i++

Output

Developer Mode Output

Simplified: Vault.sol

Changes:
- withdraw(): 3 nested ifs → early reverts
- Created modifier: whenNotPaused (applied to 4 functions)
- Replaced 8 require strings with custom errors
- Removed 12 lines dead code

Preserved: nonReentrant, CEI pattern, onlyOwner checks

Next: Run tests → forge test

Auditor Mode Output

## Simplified View: withdraw()

*For analysis only - original code unchanged*

Core logic (ignoring guards):
1. Get user balance
2. Send ETH to user
3. Update balance

Key observations:
- CEI violation: balance updated AFTER transfer (line 45)
- External call to msg.sender (potential reentrancy target)
- No reentrancy guard visible

This reveals: Potential reentrancy in withdraw()

After Simplification

• Always run tests to verify functionality preserved
• Offer to simplify related contracts
• Offer gas comparison if changes were significant

Rationalizations to Reject

Converted and distributed by TomeVault — claim your Tome and manage your conversions.