Asset Flow Analysis

Asset Flow Analysis Framework

Purpose

"Where is the money? How does it move? Where can it leak?"

Systematically map asset storage, movement paths, and potential leakage points within a protocol.

1. Asset Storage Identification

1.1 ETH Storage

// Direct balance
address(this).balance

// Wrapped ETH
WETH.balanceOf(address(this))

1.2 ERC20 Token Storage

// Token balance
IERC20(token).balanceOf(address(this))

// Internal accounting variables
mapping(address => uint256) balances;
uint256 totalDeposited;

1.3 Share/LP Tokens

// Minted amount
uint256 totalSupply;
mapping(address => uint256) shares;

// LP tokens
IUniswapV2Pair(pair).totalSupply();
IUniswapV2Pair(pair).balanceOf(address(this));

1.4 Asset Storage by Protocol Type

2. Asset Flow Mapping

2.1 Deposit Paths (Inflow)

[User Wallet] ──deposit()──► [Protocol Contract]
                                    │
                                    ▼
                              shares issued

2.2 Withdrawal Paths (Outflow)

[Protocol Contract] ──withdraw()──► [User Wallet]
         │
         ▼
    shares burned

2.3 Transfer Paths (Internal)

[Pool A] ──swap()──► [Pool B]
            │
            ▼
       price calculation

2.4 Privileged Paths

[Admin] ──emergencyWithdraw()──► [Admin Wallet]
                                 ⚠️ High risk

3. Leakage Path Exploration

3.1 Unvalidated Withdrawal

// DANGER: No access control
function withdraw(uint256 amount) external {
    token.transfer(msg.sender, amount);  // @audit Anyone can withdraw!
}

3.2 Calculation Error Leakage

// DANGER: Precision loss
function withdraw(uint256 shares) external {
    uint256 amount = shares / totalSupply * totalAssets;  // @audit Division first!
    // Multiple withdrawals accumulate rounding gains
}

3.3 Callback Bypass Leakage

// DANGER: Reentrancy through callback
function withdraw(uint256 amount) external {
    token.transfer(msg.sender, amount);  // @audit Callback occurs
    balances[msg.sender] -= amount;      // State update too late
}

3.4 Economic Attack Leakage

// DANGER: Price manipulation
function liquidate(address user) external {
    uint256 price = oracle.getPrice();  // @audit Spot price can be manipulated
    if (collateral[user] * price < debt[user]) {
        // Liquidation with manipulated price
    }
}

4. Asset Flow Diagram Template

┌─────────────────────────────────────────────────┐
│                  Asset Flow Diagram             │
├─────────────────────────────────────────────────┤
│                                                 │
│   [User Wallet]                                 │
│        │                                        │
│        │ deposit()/stake()                      │
│        ▼                                        │
│   ┌─────────────┐      ┌─────────────┐         │
│   │  Protocol   │◄────►│   Oracle    │         │
│   │  Contract   │      │  (Price)    │         │
│   └─────────────┘      └─────────────┘         │
│        │ │                                      │
│        │ │ withdraw()/swap()                    │
│        │ ▼                                      │
│   [User Wallet]    [Admin] ◄── emergencyWithdraw│
│                         │                       │
│                         ▼                       │
│                    ⚠️ Leakage Risk              │
│                                                 │
└─────────────────────────────────────────────────┘

5. Output Format

## Asset Flow Analysis Results

### Asset Storage

| Contract | Asset Type | Storage Variable | Location |
|----------|------------|------------------|----------|
| Pool | ETH | address(this).balance | Pool.sol:45 |
| Pool | ERC20 | token.balanceOf | Pool.sol:67 |
| Pool | Shares | totalSupply | Pool.sol:23 |

### Flow Paths

#### Deposit (Inflow)

User → deposit() → Pool ├── amount validation ├── token transfer └── shares issued

#### Withdrawal (Outflow)

Pool → withdraw() → User ├── shares validation ├── shares burned └── token transfer

### Leakage Risk Points

| Location | Path | Risk Level | Description |
|----------|------|------------|-------------|
| Pool.sol:142 | withdraw() | High | Insufficient access control |
| Pool.sol:200 | skim() | Medium | Admin-only unverified |

### Attack Scenarios

1. **First Depositor Attack**
   - Path: deposit → donate → next user deposit
   - Leakage: Subsequent depositor funds
   - Risk Level: High

6. Search Queries

# Find asset storage
Grep("balanceOf\\(address\\(this\\)\\)|address\\(this\\)\\.balance", glob="**/*.sol")
Grep("totalSupply|totalAssets|totalDeposited", glob="**/*.sol")

# Find deposit functions
Grep("function.*deposit|function.*stake|function.*supply", glob="**/*.sol")

# Find withdrawal functions
Grep("function.*withdraw|function.*redeem|function.*unstake", glob="**/*.sol")

# Find privileged functions
Grep("emergencyWithdraw|sweep|rescue|skim", glob="**/*.sol")

7. Attacker Mindset

• "Where is the money stored?" → Asset storage
• "Who can move the money?" → Access permissions
• "What paths can leak money?" → Leakage points
• "Can I manipulate the flow?" → Price/calculation attacks