restaking

name: restaking description: > Auto-loaded by defi-auditor agent during Phase 2 when analyzing restaking protocols. Provides patterns for: EigenLayer AVS integration, slashing propagation, operator risks, LST/LRT depeg, withdrawal queues, cross-protocol risk amplification. Core artifact: Restaking Risk Matrix. user-invocable: false

Restaking Protocol Vulnerability Analysis

2025-2026 Statistics: Restaking protocols hold $15B+ TVL (EigenLayer alone), with emerging attack vectors around slashing propagation and operator collusion causing significant concern.

Restaking Overview

Restaking allows already-staked ETH (native or LST) to secure additional protocols (AVS - Actively Validated Services) for extra yield, while introducing layered risk.

ETH Staker
    ↓ Stake
Ethereum Beacon Chain (32 ETH validator)
    ↓ Restake
EigenLayer (extends security to AVS)
    ↓ Delegate
Operators (run AVS software)
    ↓ Secure
AVS (bridges, oracles, DA layers, etc.)

Key Risk: Slashing in AVS propagates back to original ETH stake.

Why Restaking Fails (Root Causes)

Root Cause 1: Cascading Slashing

Single misbehavior triggers slashing across multiple protocols.

Operator misbehaves on AVS-A
    ↓ Slashed on AVS-A
    ↓ EigenLayer reduces operator stake
    ↓ All delegators to this operator lose funds
    ↓ Multiple AVS security degraded simultaneously

Attacker's view: "One compromised operator affects thousands of users across multiple protocols."

Root Cause 2: Unbounded Operator Trust

Stakers delegate to operators without understanding full risk exposure.

// VULNERABLE: No limit on AVS registration
function registerForAVS(address avs) external onlyOperator {
    registeredAVS[msg.sender].push(avs);  // @audit Operator can register for unlimited AVS
    // Staker funds now exposed to all AVS risks
}

Root Cause 3: Withdrawal Queue Manipulation

Long withdrawal periods create opportunities for exploitation.

// VULNERABLE: Fixed withdrawal delay
uint256 constant WITHDRAWAL_DELAY = 7 days;

function initiateWithdrawal(uint256 shares) external {
    withdrawalQueue[msg.sender] = Withdrawal(shares, block.timestamp + WITHDRAWAL_DELAY);
    // @audit If slashing occurs during delay, user loses more than expected
}

Root Cause 4: LST/LRT Depeg Risk

Liquid (re)staking tokens can depeg from underlying, causing liquidation cascades.

stETH price drops 5% vs ETH
    ↓ Lending protocols see collateral value drop
    ↓ Liquidations trigger
    ↓ More stETH sold
    ↓ Further depeg
    ↓ Cascade continues

The Restaking Risk Matrix (Core Artifact)

For each restaking integration, document:

Detection Patterns

Pattern 1: Unbounded Slashing Exposure

Root Cause: Cascading Slashing

// VULNERABLE: No cap on slashable amount
function slash(address operator, uint256 amount) external onlyAVS {
    operatorStake[operator] -= amount;  // @audit Can slash entire stake
    // No protection for delegators
}

// VULNERABLE: No limit on simultaneous slashing
mapping(address => address[]) public operatorAVS;

function executeSlashing(address operator) external {
    for (uint i = 0; i < operatorAVS[operator].length; i++) {
        IAVs(operatorAVS[operator][i]).slash(operator);
        // @audit Multiple AVS can slash simultaneously
    }
}

Attack Flow:

1. Operator registers for many AVS
2. Single misbehavior triggers multi-AVS slashing
3. Operator stake completely drained
4. Delegators lose everything
5. AVS security simultaneously compromised

Search Queries:

Grep("slash|slashing|penalty", glob="**/*.sol")
Grep("operator.*stake|stake.*operator", glob="**/*.sol")

Mitigation:

// Per-AVS slashing cap
mapping(address => uint256) public maxSlashPerAVS;

function slash(address operator, uint256 amount) external onlyAVS {
    uint256 cappedAmount = Math.min(amount, maxSlashPerAVS[msg.sender]);
    operatorStake[operator] -= cappedAmount;
}

// Global slashing cap per time period
mapping(address => uint256) public slashingThisPeriod;
uint256 constant MAX_SLASHING_PER_PERIOD = 10e18; // 10 ETH

Pattern 2: Operator Collusion

Root Cause: Insufficient Operator Validation

// VULNERABLE: No operator quality checks
function registerAsOperator() external payable {
    require(msg.value >= MIN_STAKE);
    operators[msg.sender] = true;
    // @audit Anyone with MIN_STAKE can become operator
    // No reputation, no KYC, no history check
}

// VULNERABLE: Operators can collude
function validateBlock(bytes calldata blockData) external onlyOperator {
    // @audit Multiple operators from same entity can sign
    // Sybil attack possible
}

Search Queries:

Grep("registerOperator|isOperator|onlyOperator", glob="**/*.sol")
Grep("validateBlock|sign|attest", glob="**/*.sol")

Pattern 3: Withdrawal Queue Exploitation

Root Cause: Withdrawal Queue Manipulation

// VULNERABLE: No slashing protection during withdrawal
function completeWithdrawal(uint256 withdrawalId) external {
    Withdrawal storage w = withdrawals[withdrawalId];
    require(block.timestamp >= w.unlockTime);
    
    uint256 amount = w.shares * totalAssets() / totalShares();
    // @audit If slashing occurred, totalAssets decreased
    // User receives less than expected
    
    _transfer(msg.sender, amount);
}

Attack Flow:

1. User initiates withdrawal
2. During 7-day delay, operator gets slashed
3. totalAssets decreases
4. User's share worth less
5. User receives less than when they initiated

Search Queries:

Grep("withdrawal.*queue|queue.*withdrawal", glob="**/*.sol")
Grep("initiateWithdrawal|completeWithdrawal|unstake", glob="**/*.sol")

Mitigation:

// Lock in exit value at initiation
function initiateWithdrawal(uint256 shares) external {
    uint256 assetsAtInitiation = convertToAssets(shares);
    withdrawals[msg.sender] = Withdrawal({
        shares: shares,
        assets: assetsAtInitiation,  // Lock in value
        unlockTime: block.timestamp + WITHDRAWAL_DELAY
    });
}

Pattern 4: LRT/LST Oracle Manipulation

Root Cause: Trusting Manipulable Exchange Rates

// VULNERABLE: Using spot exchange rate
function getCollateralValue(address user) external view returns (uint256) {
    uint256 lrtBalance = lrt.balanceOf(user);
    uint256 ethPerLRT = lrt.totalAssets() / lrt.totalSupply();  // @audit Manipulable!
    return lrtBalance * ethPerLRT;
}

Attack Flow:

1. Attacker donates to LRT vault (inflation attack)
2. ethPerLRT temporarily inflated
3. Borrow against inflated collateral
4. LRT price normalizes
5. Attacker has undercollateralized loan

Search Queries:

Grep("totalAssets|totalSupply|convertToAssets", glob="**/*.sol")
Grep("exchangeRate|pricePerShare|getRate", glob="**/*.sol")

Pattern 5: AVS Registration Without Stake Verification

Root Cause: Unbounded Operator Trust

// VULNERABLE: No stake verification for AVS
function registerForAVS(address avs) external {
    require(operators[msg.sender], "Not operator");
    avsOperators[avs].push(msg.sender);
    // @audit No check if operator has enough stake for this AVS
    // @audit No check if operator is already overextended
}

Attack Flow:

1. Operator with 32 ETH stake
2. Registers for 10 AVS, each expecting 32 ETH security
3. Total "promised" security: 320 ETH
4. Actual security: 32 ETH
5. Single slashing affects all AVS

Search Queries:

Grep("registerForAVS|registerAVS|joinAVS", glob="**/*.sol")
Grep("minimumStake|requiredStake|stakeRequirement", glob="**/*.sol")

Pattern 6: Reward Distribution Manipulation

Root Cause: Imbalanced Reward/Risk Distribution

// VULNERABLE: Operator takes rewards, delegators take risk
function distributeRewards(address operator) external {
    uint256 rewards = pendingRewards[operator];
    uint256 operatorCut = rewards * operatorFee / 10000;
    
    payable(operator).transfer(operatorCut);  // Operator gets rewards immediately
    // @audit But slashing affects delegators first
}

Search Queries:

Grep("distribute.*reward|reward.*distribute", glob="**/*.sol")
Grep("operatorFee|commission|operatorCut", glob="**/*.sol")

EigenLayer-Specific Patterns

Strategy Manager Integration

// Check for proper integration
interface IStrategyManager {
    function depositIntoStrategy(
        IStrategy strategy,
        IERC20 token,
        uint256 amount
    ) external returns (uint256 shares);
    
    function queueWithdrawal(
        uint256[] calldata strategyIndexes,
        IStrategy[] calldata strategies,
        uint256[] calldata shares,
        address withdrawer
    ) external returns (bytes32);
}

Key Checks:

• Withdrawal delay enforced
• Slashing conditions documented
• Operator delegation limits

Delegation Manager

// Check delegation safety
interface IDelegationManager {
    function delegateTo(address operator) external;
    function undelegate(address staker) external;
}

Key Risks:

• Delegating to malicious operator
• Undelegation timing during slashing events

Restaking Audit Checklist

Slashing

• Maximum slashing cap per AVS
• Maximum slashing cap per time period
• Slashing affects operator before delegators
• Slashing insurance fund exists

Operators

• Minimum stake requirements
• Maximum AVS registration limit
• Operator reputation tracking
• Operator exit conditions

Withdrawals

• Value locked at initiation
• Partial withdrawal supported
• Emergency withdrawal path
• Slashing during delay handled

LRT/LST Integration

• Oracle manipulation resistant
• Depeg circuit breakers
• Liquidation cascade protection
• TWAP or manipulation-resistant pricing

AVS Integration

• AVS risk disclosure
• Stake requirements per AVS
• Cross-AVS risk correlation considered

Search Query Reference

# Find restaking patterns
Grep("restake|restaking|EigenLayer|AVS", glob="**/*.sol")
Grep("operator|delegate|delegator", glob="**/*.sol")

# Find slashing
Grep("slash|slashing|penalty|punish", glob="**/*.sol")
Grep("freeze|frozen|pause", glob="**/*.sol")

# Find withdrawal patterns
Grep("withdrawal|withdraw|unstake|exit", glob="**/*.sol")
Grep("queue|delay|cooldown", glob="**/*.sol")

# Find LST/LRT
Grep("stETH|rETH|cbETH|LRT|LST", glob="**/*.sol")
Grep("liquid.*staking|restaking.*token", glob="**/*.sol")

# Find strategy patterns
Grep("strategy|strategyManager|depositIntoStrategy", glob="**/*.sol")

Severity Classification

Critical

• Unbounded slashing drains delegators
• Operator collusion enables theft
• LRT manipulation enables bad debt

High

• Withdrawal queue slashing exposure
• AVS over-registration without stake
• Reward/risk imbalance exploitation

Medium

• Insufficient operator vetting
• Missing slashing caps
• Depeg protection gaps

Rationalization Table (Reject These Excuses)