Restaking¶

Traditional Staking:
ETH → Ethereum Beacon Chain staking → Earn staking rewards (~3-4% APR)
Problem: Funds are only used to secure Ethereum mainnet

Restaking:
ETH → Ethereum staking → Restake on EigenLayer
 ↓
 ├─ Secure Ethereum mainnet (earn ETH staking rewards)
 ├─ Secure AVS 1 (earn token rewards)
 ├─ Secure AVS 2 (earn token rewards)
 └─ Secure AVS 3 (earn token rewards)

Result: One deposit, multiple yields

Definition:
The minimum cost required to attack a system

Ethereum Security:
- Staked ETH: ~32M ETH (approximately $64B)
- Attack cost: Requires controlling >33% of stake (slashing risk + post-attack token depreciation)
- Estimated attack cost: $50B+ (nearly impossible)

Small PoS Chain Security:
- Staked token market cap: $100M
- Attack cost: $50M (51% attack)
- Risk: Economically feasible, especially for high-value protocols

Problem:
- New protocols struggle to cold-start security
- Need to distribute large amounts of tokens to incentivize staking
- Low token price → Low security → Vicious cycle

AVS Leasing Ethereum Security:

Traditional Approach:
AVS issues token → Stakers stake → Secure network
Cost: High inflation + token liquidity management
Security: Depends on token market cap (weak initially)

Restaking Approach:
AVS registers on EigenLayer → Restakers choose to participate
Cost: Pay restakers small rewards (tokens or ETH)
Security: Inherits Ethereum's $64B security

Example:
An Oracle AVS needs $1B security budget
- Traditional: Need to issue and maintain a token with $1B market cap (difficult)
- Restaking: Allocate 5% from the $18B restaked ETH pool

// EigenLayer Core: One ETH deposit secures multiple AVS
contract StrategyManager {
    // Restaker's selected AVS
    mapping(address => address[]) public stakerToAVS;

    // Stake weight per AVS
    mapping(address => mapping(address => uint256)) public avsStakeWeight;

    function delegateToAVS(address avs) external {
        // 1. Restaker authorizes AVS to use their staked ETH
        stakerToAVS[msg.sender].push(avs);

        // 2. AVS gains economic security boost
        avsStakeWeight[avs][msg.sender] = getStakerETHValue(msg.sender);
    }
}

EigenDA Security Requirements:
- Needs validators to honestly store and serve data
- Attack consequences: Rollup data loss, user fund losses

Security Source:
- Participating Restaked ETH: $5B+
- Slash penalty: Up to 100% (full slashing for malicious behavior)
- Attack cost: Need to bribe validators worth $5B

Comparison:
- If EigenDA built an independent chain, it would need $5B+ token market cap (unrealistic)
- Through Restaking, it directly obtains Ethereum-level security

Ethereum Staking Slash:
- Trigger conditions: Double signing, prolonged offline
- Penalty severity: 0.5 ETH - 32 ETH
- Executor: Ethereum Beacon Chain

EigenLayer AVS Slash:
- Trigger conditions: Violating AVS-specific rules
- Penalty severity: Defined by AVS (up to 100%)
- Executor: AVS contract + DAO governance

Cumulative Risk:
Scenario: Restaker participates in Ethereum + 5 AVS simultaneously
Worst case:
- Ethereum Slash: -32 ETH
- AVS 1 Slash: -10 ETH
- AVS 2 Slash: -10 ETH
...
Total: May lose entire stake + additional penalties

// EigenDA Slashing Configuration
contract EigenDASlasher {
    struct SlashingConfig {
        uint256 minSlashAmount;      // Minimum slash: 1 ETH
        uint256 maxSlashAmount;      // Maximum slash: 100% of stake
        uint256 slashWindow;         // Slash challenge period: 7 days
        address slashAdjudicator;    // Adjudicator: DAO multisig
    }

    // Slash Scenarios
    enum SlashReason {
        DataUnavailable,       // Data unavailability
        InvalidDataAttestation,  // Invalid data attestation
        EquivocationSlashing   // Double signing (contradictory signatures)
    }

    function slash(
        address operator,
        SlashReason reason,
        bytes calldata proof
    ) external {
        // 1. Verify slash proof
        require(verifySlashProof(operator, reason, proof), "Invalid proof");

        // 2. Calculate slash amount
        uint256 slashAmount = calculateSlashAmount(operator, reason);

        // 3. Execute slash
        IEigenLayerCore(eigenLayer).slash(operator, slashAmount);

        // 4. Distribute slashed funds
        // - 50% burned
        // - 30% allocated to whistleblower
        // - 20% goes to insurance fund
    }
}

Restaker Strategies:

Conservative:
- Participate in only 1-2 mature AVS
- Choose AVS with clearly defined slash conditions
- Avoid high-risk experimental protocols
- Expected return: ETH staking 4% + AVS rewards 3% = 7% APR

Aggressive:
- Participate in 5-10 AVS
- Including high-risk, high-reward AVS
- Accept higher slash risk
- Expected return: ETH staking 4% + AVS rewards 15% = 19% APR
- Risk: Any AVS issue could result in 10-50% loss

Professional Validators:
- Run high-performance infrastructure
- Actively monitor all AVS status
- Diversify risk (multi-location deployment)
- Participate in AVS governance

Problem:
- Native Restaking (32 ETH) has a high threshold
- Funds locked, poor liquidity

Solution:
1. Use LSTs (stETH, rETH, etc.) for Restaking
2. Receive Liquid Restaking Tokens (LRT)
3. LRT can be used in DeFi

Flow:
ETH → Lido staking → stETH
stETH → EigenLayer Restaking → eigenstETH (LRT)
eigenstETH → Aave lending, Curve LP, etc.

Yield Stacking:
1. Ethereum staking rewards: 4%
2. EigenLayer AVS rewards: 5%
3. Aave lending yields: 3%
4. Protocol token rewards (EigenLayer, Aave): TBD
Total potential yield: 12%+ APR

Mechanism:
- Users deposit ETH or LST
- Renzo automatically allocates to optimal AVS combination
- Users receive ezETH (Liquid Restaking Token)

ezETH Use Cases:
- 1:1 redemption for staked ETH (with unlock period)
- Provide liquidity on Curve, Balancer
- Use as DeFi collateral

TVL: $2B+

Features:
- Non-custodial Liquid Restaking
- Users retain withdraw credentials
- Receive eETH tokens

eETH Mechanism:
- Auto-compounds restaking rewards
- Usable in DeFi
- Supports native DeFi protocol integrations

TVL: $6B+

Innovation:
- Lowers validator threshold (2 ETH vs 32 ETH)
- Uses TEE (Trusted Execution Environment) to prevent slashing
- Native Liquid Restaking

Security:
- TEE ensures validator software runs correctly
- Reduces accidental slash risk
- Suitable for validators with less technical expertise

LRT Token Comparison (2024):

| LRT     | Protocol  | TVL   | DeFi Integration | Unlock Period |
|---------|----------|-------|----------|--------|
| ezETH   | Renzo    | $2B   | ★★★★☆   | 7 days |
| eETH    | Ether.fi | $6B   | ★★★★★   | 7 days |
| pufETH  | Puffer   | $1.5B | ★★★☆☆   | Instant* |
| rsETH   | Kelp     | $800M | ★★★☆☆   | 7 days |

*Puffer achieves instant redemption via liquidity pools, may have slippage

EigenDA:
- Function: Provides low-cost DA layer for Rollups
- Security model: Restaked ETH $5B+ guarantees honest data storage
- Revenue: Validators earn DA fees paid by Rollups
- Status: Running on mainnet, multiple Rollups integrated

How It Works:
1. Rollup submits data to EigenDA
2. EigenDA validators sign to confirm storage
3. Validators must honestly serve data (or get slashed)
4. Rollup verifies signatures to ensure data availability

eOracle:
- Function: Decentralized price oracle
- Security model: Restaked ETH penalizes incorrect price reporting
- Advantage: More decentralized and lower cost compared to Chainlink

Slash Mechanism:
- Price deviation >5% from median: Warning
- Deviation >10%: Slash 10% of stake
- Malicious price manipulation: Slash 100% of stake

Hyperlane + EigenLayer:
- Function: Multi-chain message passing
- Security model: Validator set composed of Restakers
- Validators must run multi-chain nodes to verify cross-chain messages

Security:
- Bridge attack cost = Value of Restaked ETH
- Far exceeds traditional multisig bridges (millions of dollars)

Espresso:
- Function: Provides decentralized sequencing for multiple Rollups
- Advantage: Cross-Rollup atomic composability
- Security model: Restakers run sequencer nodes

Revenue:
- Sequencer fees (Rollup MEV)
- Cross-Rollup arbitrage opportunities

Brevis:
- Function: Off-chain ZK computation, on-chain verification
- Use cases: Complex on-chain data queries, historical state proofs
- Security model: Incorrect computation gets slashed

Example:
Query: "Addresses that traded on Uniswap in the last 30 days"
- Direct on-chain query: Extremely high Gas cost (infeasible)
- Brevis: Off-chain computation + ZK proof, on-chain verification
- Restakers guarantee computation correctness

2024: 50+ AVS, Total TVL $22B
2025E: 200+ AVS, Total TVL $50B
2026E: 500+ AVS, Total TVL $100B+

Potential AVS Types:
- AI inference verification networks
- Decentralized RPC networks
- MEV protection layers
- On-chain game servers
- Decentralized storage verification
- ZK proof generation networks

EigenLayer Contract Architecture:

┌─────────────────────────────────────┐
│ User / Restaker                      │
└─────────────────────────────────────┘
            ↓ (deposit ETH/LST)
┌─────────────────────────────────────┐
│ StrategyManager.sol                  │
│ - Manages user deposits              │
│ - Tracks staking strategies          │
│ - Processes withdrawal requests      │
└─────────────────────────────────────┘
            ↓ (delegate to operator)
┌─────────────────────────────────────┐
│ DelegationManager.sol                │
│ - Restaker delegates to Operator     │
│ - Operator registration & management │
│ - Stake weight calculation           │
└─────────────────────────────────────┘
            ↓ (register AVS)
┌─────────────────────────────────────┐
│ AVSDirectory.sol                     │
│ - AVS registration and configuration│
│ - Operator selects AVS to join       │
│ - AVS slash permission management    │
└─────────────────────────────────────┘
            ↓ (slash on fault)
┌─────────────────────────────────────┐
│ Slasher.sol                          │
│ - Executes slash penalties           │
│ - Slash challenge period management  │
│ - Slashed fund distribution          │
└─────────────────────────────────────┘

// Step 1: User deposits stETH into EigenLayer
interface IStrategyManager {
    function depositIntoStrategy(
        IStrategy strategy,      // stETH strategy
        IERC20 token,           // stETH token
        uint256 amount          // Deposit amount
    ) external returns (uint256 shares);
}

// User calls
strategyManager.depositIntoStrategy(
    stETHStrategy,
    stETH,
    10 ether
);
// User receives EigenLayer shares (proof of stake)

// Step 2: User delegates to Operator
interface IDelegationManager {
    function delegateTo(
        address operator,
        ISignatureUtils.SignatureWithExpiry calldata signature,
        bytes32 approverSalt
    ) external;
}

// User selects Operator (professional validator)
delegationManager.delegateTo(
    operatorAddress,
    signature,
    salt
);

// Step 3: Operator registers for AVS
interface IAVSDirectory {
    function registerOperatorToAVS(
        address operator,
        ISignatureUtils.SignatureWithExpiry calldata operatorSignature
    ) external;
}

// Operator provides service for EigenDA
avsDirectory.registerOperatorToAVS(
    operator,
    signature
);

Operator = Professional Validator

Responsibilities:
1. Run AVS-required validation software
   - EigenDA: Store and serve data
   - eOracle: Fetch and report prices
   - Hyperlane: Verify cross-chain messages

2. Accept Restaker delegations
   - Restakers don't need to run nodes themselves
   - Operators represent Restakers in AVS participation
   - Operators charge delegation fees (e.g., 10%)

3. Manage slash risk
   - Ensure high availability
   - Correctly execute AVS tasks
   - Avoid being slashed

Revenue Distribution:
Scenario: Operator manages 1,000 ETH in delegated stake
Monthly AVS rewards: 10 ETH
- Operator fee: 10% = 1 ETH
- Restakers: 90% = 9 ETH (distributed by share)

// Step 1: Initiate withdrawal request
interface IStrategyManager {
    function queueWithdrawal(
        QueuedWithdrawalParams[] calldata params
    ) external returns (bytes32);
}

strategyManager.queueWithdrawal({
    strategies: [stETHStrategy],
    shares: [10 ether],
    withdrawer: msg.sender
});
// Returns withdrawalRoot (withdrawal identifier)

// Step 2: Wait 7 days (slash challenge period)

// Step 3: Complete withdrawal
interface IStrategyManager {
    function completeQueuedWithdrawal(
        Withdrawal calldata withdrawal,
        IERC20[] calldata tokens,
        uint256 middlewareTimesIndex,
        bool receiveAsTokens
    ) external;
}

// Execute after 7 days
strategyManager.completeQueuedWithdrawal(
    withdrawal,
    [stETH],
    0,
    true  // Receive stETH directly (or choose false to retain shares)
);

1. Multi-Asset Restaking:
   - Not limited to ETH/LST
   - Supports any ERC-20 (USDC, WBTC, etc.)
   - AVS customizes accepted staking assets

2. Modular Architecture:
   - Networks (AVS) can customize slash logic
   - Operators can choose which Networks to join
   - More flexible trust assumptions

3. Instant Withdrawal Option:
   - No 7-day wait required (via liquidity pools)
   - Or choose standard withdrawal (no fees)

| Feature          | EigenLayer       | Symbiotic         |
|-----------------|-----------------|------------------|
| Supported Assets | ETH + LST       | Any ERC-20       |
| Architecture     | Semi-modular     | Fully modular     |
| Slash Flexibility| AVS preset rules | Fully customizable|
| Withdrawal Time  | 7 days fixed    | Instant or delayed|
| Ecosystem        | Largest ($18B)  | Fast growing ($2.5B)|
| Led by           | EigenLabs       | Lido + Paradigm  |

Mellow LRT (Built on Symbiotic):
- Users deposit multiple assets (stETH, rETH, WBTC)
- Vault automatically allocates to optimal Network combinations
- Receive mevETH (composite LRT)

Strategy Example:
User deposits: 10 stETH
Mellow allocation:
- 50% → EigenDA (low risk, stable yield)
- 30% → Hyperlane (medium risk, moderate yield)
- 20% → Experimental AVS (high risk, high yield)

Expected Returns:
- Base stETH: 4%
- Network rewards: 6% (weighted average)
- Total APY: ≈ 10%

1. Multi-Chain Support:
   - Ethereum: ETH, stETH
   - Arbitrum: ARB
   - Mantle: MNT
   - Blast: BLAST
   - ... 10+ chains

2. Distributed Secure Services (DSS):
   - Similar to AVS
   - But supports security needs of non-Ethereum chains

3. Cross-Chain Unified Staking:
   - Users' assets across multiple chains are aggregated
   - Unified participation in DSS
   - Cross-chain yield aggregation

Problem:
- An Oracle needs to verify prices across multiple chains
- Single-chain Restaking cannot cover this

Karak Solution:
1. Restaker stakes ETH on Ethereum
2. Stakes ARB on Arbitrum
3. Stakes MNT on Mantle
4. Karak aggregates stake weights
5. Restaker runs multi-chain Oracle nodes
6. Receives aggregated multi-chain yields

Returns:
- Ethereum Oracle rewards: 2% APR
- Arbitrum Oracle rewards: 3% APR
- Mantle Oracle rewards: 5% APR
- Total yield: 10% APR (on top of base staking rewards)

New L1/L2 Chain Bootstrap Dilemma:
1. Need a validator network
2. Validators need to stake tokens (security)
3. But tokens have low market cap initially → Low stake value → Weak security
4. Weak security → Users don't trust → Token price stays low
5. Vicious cycle

Case Study: A New Rollup Using EigenLayer

Traditional Approach:
- Issue token, incentivize staking
- Need $500M stake market cap for basic security
- But initial token market cap is only $50M → Cannot achieve
- Takes months or even years to accumulate

Restaking Approach:
- Register as AVS on EigenLayer
- Restakers choose to participate (low barrier)
- Day one can get $1B+ security
- Only need to pay small rewards (<$100K/year)

Timeline Comparison:
- Traditional: 6-12 months to achieve security
- Restaking: 1 day

AltLayer: Rollup-as-a-Service Platform

Integration:
- AltLayer provides rapid Rollup deployment tools
- Rollups automatically connect to EigenDA (low-cost DA)
- Rollup sequencers run by EigenLayer Restakers

Advantages:
- New Rollups launch with $B-level security
- No need to build validator networks
- Focus on application layer development

Current State (Arbitrum, Optimism, etc.):
- Sequencer is centralized (single entity operates)
- Censorship risk: Sequencer can refuse to include transactions
- Downtime risk: Sequencer failure → Entire Rollup halts
- MEV extraction: Sequencer controls transaction ordering, monopolizes MEV

Need: Decentralized sequencer

Espresso Sequencer + EigenLayer:

Architecture:
1. Restakers run sequencer nodes
2. Use HotShot consensus (high-performance BFT)
3. Provide sequencing services for multiple Rollups

Advantages:
a) Decentralization:
   - Hundreds of Restaker nodes
   - No single point of failure
   - Censorship resistant

b) Cross-Rollup Interoperability:
   - Multiple Rollups share sequencer
   - Atomic cross-Rollup transactions (no bridge needed)

c) Fair MEV Distribution:
   - MEV auction mechanism
   - Revenue distributed to Restakers and Rollups

Example:
┌─────────┐  ┌─────────┐  ┌─────────┐
│Rollup A │  │Rollup B │  │Rollup C │
└────┬────┘  └────┬────┘  └────┬────┘
     └───────────┬────────────┘
          ┌──────▼──────┐
          │  Espresso   │
          │  Sequencer  │
          │ (Restaked)  │
          └─────────────┘

Cross-Rollup Atomic Transaction Example:
User operation:
- Sell ETH on Rollup A
- Buy BTC on Rollup B
- Deposit into lending protocol on Rollup C
All executed atomically in a single Espresso block

Typical DeFi Protocol (Aave):
- Needs 30+ price feeds
- Each feed: $100K - $500K/year
- Total cost: $3M - $15M/year
- 30-50% of protocol operating costs

Smaller Protocols:
- Cannot afford Chainlink costs
- Forced to use centralized oracles
- Or rely on AMM prices (manipulable)

Architecture:
- Restakers run Oracle nodes
- Fetch and sign price data
- Incorrect price reports get slashed

Cost Comparison:
Chainlink ETH/USD Feed:
- Cost: $300K/year
- Node count: 31
- Update frequency: 1 hour or 0.5% deviation

eOracle ETH/USD Feed:
- Cost: $30K/year (10x cheaper)
- Node count: 100+ (more decentralized)
- Update frequency: 10 minutes or 0.2% deviation
- Security: Restaked ETH $500M+

Suitable Scenarios:
- Small DeFi protocols
- Long-tail asset prices
- High-frequency update needs
- Low-latency Oracle

Strategy: ETH → stETH → ezETH → Curve LP → Convex

Layer 1: Lido Staking
10 ETH → stETH
Yield: 4% APR (Ethereum staking rewards)

Layer 2: Renzo Restaking
stETH → ezETH
Yield: +5% APR (AVS rewards)

Layer 3: Curve LP
ezETH + ETH → Curve LP
Yield: +3% APR (trading fees + CRV rewards)

Layer 4: Convex Boost
Curve LP → Convex staking
Yield: +4% APR (CVX rewards + boost)

Total Yield: 16% APR
Protocol token rewards: EIGEN, CRV, CVX (not included)

Risks:
- Smart contract risk (4 layers of protocols)
- Slash risk (Restaking)
- ezETH depeg risk
- Curve LP impermanent loss

Pendle + ezETH:
- ezETH Principal Token (PT) and Yield Token (YT) separation
- YT traders: Bullish on AVS reward growth
- PT holders: Earn fixed yield

Data:
ezETH YT (6-month term):
- Implied APY: 25% (market expectation for AVS rewards)
- Actual APY: 18% (EigenLayer points + AVS rewards)

PT-ezETH (6-month term):
- Fixed APY: 10%
- No slash risk exposure (yield already locked in)

Problem:
- Infura, Alchemy centralized RPC
- Censorship risk, single point of failure

Solution: AVS-powered RPC

Architecture:
1. Restakers run Ethereum full nodes
2. Provide RPC services
3. Incorrect responses get slashed

Revenue Model:
- Users pay RPC call fees
- Restakers earn fee share
- Cheaper than centralized RPC (no massive profit margins)

Security:
- Restaked ETH $100M+ guarantees honest service
- Multi-node redundancy, no single point of failure

Example Protocol: Lava Network + EigenLayer

Problem:
- AI model inference results are hard to verify
- Centralized AI APIs (OpenAI) cannot prove correctness

Solution: Decentralized AI Inference AVS

Workflow:
1. User submits AI inference request (e.g., image recognition)
2. Multiple Restaker nodes independently run inference
3. Use ZK proofs or majority voting to verify results
4. Incorrect inference gets slashed

Applications:
- On-chain game NPC AI
- DeFi risk assessment models
- NFT generation verification

Traditional Staking:
10,000 ETH → Ethereum staking → 4% APR = 400 ETH/year

Restaking:
10,000 ETH → Ethereum staking → 4% APR = 400 ETH/year
         └→ 3 AVS → 6% APR = 600 ETH/year
         Total yield: 1,000 ETH/year (+150%)

Capital Utilization:
- Traditional: 100% (single purpose)
- Restaking: 200-400% (multi-purpose)

New Protocol Cold-Start Time:
- Traditional PoS: 6-24 months to achieve basic security
- Restaking: 1 day (connect to EigenLayer)

Cost:
- Traditional: Issue tokens + high inflation incentives (millions of dollars)
- Restaking: Pay small AVS rewards (tens of thousands of dollars)

Multiple AVS Combinations:
Scenario: A DeFi protocol needs:
1. Price Oracle (eOracle)
2. Cross-chain bridge (Hyperlane)
3. Data storage (EigenDA)

Restaking Approach:
- All services share the same Restaked ETH security
- No need to build separate validator networks
- Cost grows linearly rather than exponentially

Ethereum Validator Dilemma:
- Single revenue source (ETH staking rewards)
- APR declining (as staking increases)
- 2023: 5.5% → 2024: 3.5%

Restaking Solution:
- Multiple AVS revenue streams
- Hedge against single protocol risk
- More stable total returns

Example:
Validator participates in 5 AVS:
- AVS 1 rewards decrease → AVS 2, 3 may increase
- Total yield volatility reduced

Risk Contagion Chain:
Ethereum Slash → EigenLayer Slash → AVS Failure → DeFi Protocol Malfunction

Hypothetical Case:
1. Large number of Restakers slashed on EigenLayer
2. Multiple AVS lose security (Restaked ETH decreases)
3. DeFi protocols depending on these AVS face attacks
4. Chain reaction causes market panic
5. ETH price drops → Security further decreases

2024 Concerns:
- $18B Restaked ETH
- If 10% is slashed = $1.8B loss
- Could trigger a systemic crypto market crisis

Scenario: Operator participates in 10 AVS simultaneously

AVS 1 has a bug → Operator slashed 20%
→ Operator's stake weight drops
→ Other 9 AVS security decreases
→ May trigger security thresholds on more AVS
→ Operator forced to exit some AVS
→ These AVS lose validators
→ Vicious cycle

Real-World Case:
- In 2024, an Operator was slashed by multiple AVS due to software bug
- Total loss: 500 ETH (approximately $1M)
- Forced to exit all AVS
- Restakers delegated to that Operator suffered losses

LRT Depeg Risk:
Scenario: Market panic, massive user redemptions

ezETH market price: $1,900 (normal = $2,000)
Cause:
- Massive selling
- 7-day unlock period → Cannot redeem instantly
- Insufficient liquidity pool depth

Consequences:
- Users using ezETH as collateral get liquidated
- Panic intensifies, more selling
- Repeat of 2022 stETH depeg

Risk Mitigation:
- Deep liquidity pools
- Diversified LRT redemption mechanisms
- Limit leverage usage

Data (EigenLayer 2024):
- Top 10 Operators control 60%+ of Restaked ETH
- Some AVS have only 3-5 Operators

Risks:
- Operator collusion
- Single point of failure (Top Operator downtime)
- Regulatory pressure (targeting large Operators)

Hypothetical Case:
Regulators require Top 3 Operators (controlling 40% of stake) to:
- Implement transaction censorship
- Provide user data
- Deny service to certain regions

Result:
- AVS decentralization level drops significantly
- Censorship resistance compromised

Problem:
- Anyone can create an AVS
- Some AVS may have security vulnerabilities
- Restakers struggle to evaluate AVS quality

Risky AVS Characteristics:
1. Complex slash conditions (easy to accidentally trigger)
2. Unaudited code
3. Unclear economic model
4. Anonymous team

Case:
- In 2024, an experimental AVS slashed 30 Operators due to a bug
- Total losses >$5M
- Community demanded compensation, triggering governance dispute
- EigenLayer DAO eventually voted for partial compensation

Potential Regulatory Issues:

1. Securities Classification:
   - Are LRTs securities?
   - Do AVS tokens need registration?

2. Operator Liability:
   - Do they need MSB licenses?
   - KYC/AML obligations?

3. Restaker Rights:
   - How to resolve slash disputes?
   - Investor protection?

Hypothetical Regulatory Scenario:
SEC classifies LRT as securities
→ Protocols need to register
→ Services restricted for U.S. users
→ Protocols may geofence the U.S.
→ Or go fully decentralized (ungovernable)

Goals:
- Unified AVS interface
- Lower development barriers
- Improve interoperability

Technology:
ERC-7683 (Intents) + EigenLayer
- AVS can leverage intent infrastructure
- Cross-chain Restaking standardization
- Solver = Restaker (unified role)

Future Vision:
┌─────────────────────────────────────┐
│ Universal Restaking Layer            │
│ - EigenLayer                         │
│ - Symbiotic                          │
│ - Karak                              │
│ - Unified standards, interoperable   │
└─────────────────────────────────────┘
            ↓
┌─────────────────────────────────────┐
│ AVS Marketplace                      │
│ - Standardized AVS SDK               │
│ - One-click AVS deployment           │
│ - Automated auditing and ratings     │
└─────────────────────────────────────┘

Cosmos IBC + Restaking:
- Stake ATOM on Cosmos Hub
- Restaking secures other Cosmos chains
- Interchain Security + Restaking convergence

Polkadot + Restaking:
- DOT stakers Restaking to secure Parachains
- Lower Parachain bootstrap costs

Bitcoin Restaking (Babylon):
- Leverage BTC economic security
- Secure PoS chains and AVS
- Expand BTC use cases

Restaking-powered AI Stack:

1. Compute Layer:
   - Restakers provide GPU compute
   - Run AI inference and training
   - Incorrect results → Slash

2. Data Layer:
   - Decentralized data storage (EigenDA, etc.)
   - Privacy protection (ZK proof)
   - Data provenance verification

3. Verification Layer:
   - ZK proof verifies AI computation correctness
   - Multi-node consensus
   - Prevents malicious outputs

Use Cases:
- On-chain game AI NPCs (real-time inference)
- DeFi smart risk management (on-chain models)
- NFT generation verification (prevent plagiarism)

Trends:
- Traditional financial institutions exploring Restaking
- Custodial services (Coinbase, Anchorage)
- Compliance frameworks

Coinbase Restaking Service:
- Enterprise clients one-click Restaking
- Compliant KYC/AML
- Insurance coverage (reduces slash risk)
- Automated tax reporting

Benefits:
- Institutional capital inflow = Significant TVL growth
- More professional Operators
- Improved AVS security

Nexus Mutual Restaking Cover:
- Insures against slash losses
- Covers smart contract risk
- Premium: 1-3% APR

Example:
Restaker stakes 100 ETH:
- Purchase slash insurance (2% = 2 ETH/year)
- Restaking yield: 10% = 10 ETH/year
- Net yield: 8 ETH/year
- Zero slash risk

Insurance Pool:
- Restakers pay premiums
- Claims paid when slashing occurs
- Similar to traditional insurance model

Path 1: Enhanced Decentralization
- Fully on-chain governance
- Anonymous Operators
- Censorship-resistant design
- Similar to Tornado Cash

Path 2: Compliance
- KYC/AML integration
- Compliant Operator whitelist
- Regulatory reporting
- Targeting institutions

Path 3: Dual-Track
- Censorship-resistant version (decentralized)
- Compliant version (institutional)
- Users choose freely
- Similar to DeFi and CeFi coexistence