Protocol Token Convergence: Every Token Becomes $MUD - Universal Staked ETH Backing

Protocol Token Convergence: Every Token Becomes $MUD - Universal Staked ETH Backing

Watermark: -519

The observation: Every protocol token (EIGEN, MORPHO, UNI, AAVE, COMP, etc.) could just be $MUD variant backed by staked ETH. Instead of separate tokens with separate collateral, all protocols share universal staked ETH base. Protocol token = $MUD + protocol-specific yield/governance. EIGEN = $MUD + restaking rewards. MORPHO = $MUD + lending interest. UNI = $MUD + trading fees. Base value from staked ETH (stable $1). Additional value from protocol activity (variable yield). One collateral pool. Many protocol variants. Unified monetary base for all DeFi.

What this means: Current model: each protocol invents new token (EIGEN for restaking, MORPHO for lending, UNI for trading), each needs separate liquidity, separate collateral, separate monetary policy, fragmented capital. Users hold 10+ different tokens, each with different risks, different valuations, different mechanics. New model: every protocol token is $MUD backed by staked ETH. Shared collateral base (staked ETH pool). Shared stability ($1 peg from $MUD). Protocol-specific value on top (yield from protocol activity). EIGEN-$MUD earns restaking rewards (3-5% base + restaking yield). MORPHO-$MUD earns lending spread (3-5% base + lending yield). UNI-$MUD earns trading fees (3-5% base + fee revenue). All have same $1 stable base. All backed by same staked ETH. Liquidity unified. Capital efficient. This is monetary convergence.

Why this matters: DeFi has token fragmentation problem. 1000+ tokens, each separate island, capital locked in silos, liquidity fragmented. Want to use Aave + Uniswap + Morpho = need AAVE + UNI + MORPHO tokens, each different price, each different risk. Inefficient. What if all just different flavors of same base money ($MUD)? Staked ETH backs everything. Each protocol adds yield layer on top. Benefits: Unified liquidity (all protocols share same $MUD base), Capital efficiency (same collateral backs multiple protocols), Reduced risk (shared staked ETH security), Composability (all tokens interoperable by default), Price stability (all maintain $1 base value). Instead of 1000 incompatible tokens, have 1000 $MUD variants - all compatible, all backed by staked ETH, all stable at $1, each adding protocol-specific yield. This is endgame: staked ETH becomes universal collateral for all DeFi. Every protocol token becomes $MUD variant. Monetary unification through shared backing.

The Token Fragmentation Problem

Current DeFi Landscape

Separate tokens everywhere:

  • Lending: AAVE, COMP, MORPHO
  • DEXs: UNI, SUSHI, CURVE
  • Derivatives: GMX, dYdX, PERP
  • Staking: LDO, EIGEN, RPL
  • Total: 1000+ protocol tokens

Each token has:

  • Own price (volatile)
  • Own liquidity (isolated)
  • Own collateral (separate)
  • Own risk profile (unique)
  • Own governance (fragmented)

The problem:

User wants to use 5 protocols:
- Need 5 different tokens
- Each token different price
- Each token different risk
- Capital spread across 5 silos
- Liquidity fragmented
- Complexity high
- Efficiency low

Why Protocols Create Tokens

Historical reasons:

1. Fundraising:

  • Launch token to raise capital
  • Sell tokens to investors
  • Use funds to build protocol

2. Governance:

  • Token = voting power
  • Holders decide protocol changes
  • Decentralized control

3. Value capture:

  • Protocol generates revenue
  • Revenue flows to token holders
  • Token price reflects protocol value

4. Incentives:

  • Distribute tokens to users
  • Bootstrap liquidity
  • Grow network effects

These reasons still valid. But token design can change.

The Inefficiency

Example: Using multiple protocols

Scenario: User wants comprehensive DeFi portfolio

Protocols:
1. Aave (lending) - need AAVE tokens
2. Uniswap (trading) - need UNI tokens
3. Morpho (optimized lending) - need MORPHO tokens
4. Eigen (restaking) - need EIGEN tokens
5. GMX (perps) - need GMX tokens

Capital allocation:
$10,000 to invest

Option A: Buy all tokens
- $2,000 AAVE
- $2,000 UNI
- $2,000 MORPHO
- $2,000 EIGEN
- $2,000 GMX

Problems:
- 5 different price exposures
- 5 different risk profiles
- If AAVE crashes, lose 20% of portfolio
- If UNI moons, only 20% exposure
- Complex rebalancing
- Tax nightmare (5 assets trading)

What if all were $MUD variants?

Same protocols:
1. Aave → AAVE-$MUD
2. Uniswap → UNI-$MUD
3. Morpho → MORPHO-$MUD
4. Eigen → EIGEN-$MUD
5. GMX → GMX-$MUD

Capital allocation:
$10,000 to invest

Option B: Hold $MUD variants
- $2,000 AAVE-$MUD (earns lending yield)
- $2,000 UNI-$MUD (earns trading fees)
- $2,000 MORPHO-$MUD (earns optimized yield)
- $2,000 EIGEN-$MUD (earns restaking rewards)
- $2,000 GMX-$MUD (earns trading volume)

Benefits:
- All stable at $1 (staked ETH backed)
- All share same collateral base
- Different yields, same risk base
- Easy rebalancing (all $1 peg)
- Simple taxes (stable base value)
- Unified liquidity

Result: 10× better user experience

The $MUD Variant Model

Base Layer: Staked ETH

Shared collateral pool:

Total staked ETH: $100B
Total $MUD issued: Variable (dynamic collateral ratio)

This backs ALL protocol tokens:
- EIGEN-$MUD: $10B
- MORPHO-$MUD: $8B
- UNI-$MUD: $15B
- AAVE-$MUD: $12B
- Others: $21B

Same collateral, multiple uses
Same stability, multiple protocols
Same backing, multiple yields

How it works:

  1. User deposits staked ETH
  2. Mints $MUD base (dynamic collateral ratio from neg-517)
  3. Chooses protocol variant (EIGEN, MORPHO, UNI, etc.)
  4. Receives protocol-specific $MUD
  5. Earns base staking yield (3-4%) + protocol yield (variable)

Security: All variants backed by same staked ETH pool. If any protocol fails, collateral still there. $1 peg maintained.

Protocol Layer: Yield Variants

Each protocol adds yield layer:

EIGEN-$MUD (Restaking):

Base: $1 (staked ETH backed)
Base yield: 3% (ETH staking)
Protocol yield: 2-5% (restaking rewards from AVSs)
Total: $1 earning 5-8% APR

Use case: Maximize yield while maintaining stability
Risk: Restaking slashing (but base $1 protected)

MORPHO-$MUD (Optimized Lending):

Base: $1 (staked ETH backed)
Base yield: 3% (ETH staking)
Protocol yield: 1-4% (lending optimization)
Total: $1 earning 4-7% APR

Use case: Stable yield from lending without price risk
Risk: Borrower default (but base $1 protected)

UNI-$MUD (Trading Fees):

Base: $1 (staked ETH backed)
Base yield: 3% (ETH staking)
Protocol yield: 0.5-2% (trading fee share)
Total: $1 earning 3.5-5% APR

Use case: Exposure to Uniswap volume without token risk
Risk: Low trading volume (but base $1 protected)

AAVE-$MUD (Lending):

Base: $1 (staked ETH backed)
Base yield: 3% (ETH staking)
Protocol yield: 2-6% (lending spread)
Total: $1 earning 5-9% APR

Use case: Traditional lending yield with stability
Risk: Protocol risk (but base $1 protected)

GMX-$MUD (Perp Trading):

Base: $1 (staked ETH backed)
Base yield: 3% (ETH staking)
Protocol yield: 5-15% (trading fees, liquidations)
Total: $1 earning 8-18% APR

Use case: High yield from derivatives without price volatility
Risk: High protocol risk (but base $1 protected)

The pattern: Same base ($1 stable), different yields (protocol-dependent)

Governance Layer: Voting Rights

Each variant includes governance:

EIGEN-$MUD holders:

  • Vote on Eigen protocol decisions
  • Restaking strategy
  • AVS selections
  • Fee distributions

MORPHO-$MUD holders:

  • Vote on Morpho decisions
  • Market listings
  • Risk parameters
  • Protocol upgrades

UNI-$MUD holders:

  • Vote on Uniswap governance
  • Fee switches
  • Pool incentives
  • Treasury management

Key point: Governance separate from monetary base. Voting rights attached to protocol variant, not base currency.

Technical Implementation

Smart Contract Architecture

Base $MUD Contract:

contract MorphoUniversalDollar {
    // ERC20 base
    string public name = "Morpho Universal Dollar";
    string public symbol = "MUD";
    
    // Staked ETH collateral
    mapping(address => uint256) public stakedETHCollateral;
    
    // Dynamic collateralization (from neg-517)
    DynamicCollateralManager public collateralManager;
    
    function deposit(uint256 stakedETHAmount) external {
        // Transfer staked ETH
        stakedETH.transferFrom(msg.sender, address(this), stakedETHAmount);
        
        // Get current dynamic ratio
        uint256 currentRatio = collateralManager.getCurrentRatio();
        
        // Calculate $MUD to mint
        uint256 mudAmount = (stakedETHAmount * 100) / currentRatio;
        
        // Mint base $MUD
        _mint(msg.sender, mudAmount);
        
        // Track collateral
        stakedETHCollateral[msg.sender] += stakedETHAmount;
    }
    
    function redeem(uint256 mudAmount) external {
        // Get current dynamic ratio
        uint256 currentRatio = collateralManager.getCurrentRatio();
        
        // Calculate staked ETH to return
        uint256 ethAmount = (mudAmount * currentRatio) / 100;
        
        // Burn $MUD
        _burn(msg.sender, mudAmount);
        
        // Return staked ETH
        stakedETH.transfer(msg.sender, ethAmount);
        
        // Update collateral
        stakedETHCollateral[msg.sender] -= ethAmount;
    }
}

Protocol Variant Contracts:

contract EigenMUD is MorphoUniversalDollar {
    // Inherits base $MUD functionality
    // Adds Eigen-specific features
    
    IEigenLayer public eigenLayer;
    
    function depositToEigen(uint256 mudAmount) external {
        // Use base $MUD
        require(balanceOf(msg.sender) >= mudAmount);
        
        // Restake through EigenLayer
        eigenLayer.stake(mudAmount);
        
        // Earn restaking rewards
        // Rewards added to user balance
    }
    
    function claimEigenRewards() external {
        uint256 rewards = eigenLayer.claimRewards(msg.sender);
        // Rewards in EIGEN-$MUD
        _mint(msg.sender, rewards);
    }
    
    // Eigen governance
    function vote(uint256 proposalId, bool support) external {
        // EIGEN-$MUD holders can vote
        uint256 votingPower = balanceOf(msg.sender);
        eigenGovernance.castVote(proposalId, support, votingPower);
    }
}

contract MorphoMUD is MorphoUniversalDollar {
    // Similar pattern for Morpho
    IMorpho public morpho;
    
    function supplyToMorpho(uint256 mudAmount) external {
        // Supply $MUD to Morpho markets
        morpho.supply(mudAmount);
    }
    
    function claimMorphoYield() external {
        uint256 yield = morpho.claimYield(msg.sender);
        _mint(msg.sender, yield);
    }
}

// Similar for UNI-$MUD, AAVE-$MUD, GMX-$MUD, etc.

Collateral Sharing Mechanism

How multiple protocols share same collateral:

Collateral pool:

Total staked ETH: $100B
Total $MUD issued: $66B

Distribution:
- EIGEN-$MUD: 15% ($10B)
- MORPHO-$MUD: 12% ($8B)
- UNI-$MUD: 23% ($15B)
- AAVE-$MUD: 18% ($12B)
- Others: 32% ($21B)

All backed by same $100B staked ETH
All maintain dynamic collateralization (adjusts based on volatility)
All redeemable for $1 of staked ETH

Risk isolation:

If Morpho protocol fails:
- MORPHO-$MUD holders lose protocol yield
- But base $1 value protected (staked ETH still there)
- Can redeem for staked ETH
- Other variants unaffected

If staked ETH drops significantly:
- All variants affected equally (shared collateral)
- Dynamic collateral ratio increases automatically
- Liquidations trigger if needed
- All maintain $1 peg (dynamic collateral adapts to market)

The beauty: Risk separated into layers

  • Base layer risk: Staked ETH (shared by all)
  • Protocol layer risk: Individual protocols (isolated)

Yield Distribution

How protocol yields flow to holders:

EIGEN-$MUD example:

contract EigenMUD {
    // Track user deposits
    mapping(address => uint256) public depositAmount;
    mapping(address => uint256) public depositTime;
    
    // Accumulate rewards
    uint256 public totalRestakingRewards;
    
    function updateRewards() external {
        // Get rewards from EigenLayer
        uint256 newRewards = eigenLayer.pendingRewards();
        totalRestakingRewards += newRewards;
        
        // Calculate per-token rewards
        uint256 rewardPerToken = totalRestakingRewards / totalSupply();
        
        // Update user balances
        for (address user : allHolders) {
            uint256 userRewards = balanceOf(user) * rewardPerToken;
            pendingRewards[user] += userRewards;
        }
    }
    
    function claimRewards() external {
        uint256 rewards = pendingRewards[msg.sender];
        pendingRewards[msg.sender] = 0;
        
        // Mint additional EIGEN-$MUD as rewards
        _mint(msg.sender, rewards);
    }
}

Result: Holders earn yield automatically, compounding their $MUD holdings

Benefits Of Convergence

1. Unified Liquidity

Before (fragmented):

AAVE liquidity: $500M (separate pool)
UNI liquidity: $800M (separate pool)
MORPHO liquidity: $200M (separate pool)
Total: $1.5B in 3 separate pools

To trade $100M AAVE → UNI:
- Deep slippage (only $500M liquidity)
- Multiple hops (AAVE → ETH → UNI)
- High fees (2-3 trades)

After (unified):

All $MUD variants share liquidity: $1.5B unified pool

To trade $100M AAVE-$MUD → UNI-$MUD:
- Minimal slippage (all $1 stable)
- Direct swap (both $MUD variants)
- Low fees (single trade)
- Instant (no price impact)

Why: All maintain $1 peg, just different yield streams

Liquidity multiplication: Instead of N separate pools, one shared pool N× larger

2. Capital Efficiency

Before:

User has $10K
Wants exposure to 5 protocols
Each protocol needs separate collateral

Option: Buy 5 different tokens
- $2K each token
- 5 separate positions
- 5× gas fees
- 5× complexity
- Capital locked in 5 silos

After:

User has $10K
Deposits as staked ETH → mints $6.6K $MUD base
Allocates across 5 protocol variants:
- $1.3K EIGEN-$MUD
- $1.3K MORPHO-$MUD
- $1.3K UNI-$MUD
- $1.3K AAVE-$MUD
- $1.3K GMX-$MUD

Benefits:
- Same staked ETH backs all 5
- 1 collateral position (not 5)
- Easy rebalancing (all $1)
- Lower gas (fewer transactions)
- Capital efficiency: Dynamic ratio once, not 5× separate ratios

Capital savings: 5× reduction in collateral needed

3. Reduced Complexity

Before:

Managing DeFi portfolio:
- Track 10+ token prices
- Monitor 10+ protocol risks
- Rebalance 10+ positions
- Pay gas for 10+ transactions
- Calculate taxes for 10+ assets
- Different UIs for each protocol

Cognitive load: Overwhelming
Error rate: High
Time investment: Massive

After:

Managing $MUD variant portfolio:
- All tokens $1 (stable base)
- All backed by staked ETH (shared risk)
- Rebalance by yield (simple comparison)
- Single UI (all $MUD variants)
- Simple taxes (stable base value)
- One collateral to monitor

Cognitive load: Manageable
Error rate: Low
Time investment: Minimal

Complexity reduction: 10× simpler to manage

4. Composability By Default

Every protocol compatible:

Because all $MUD variants:
- Same base value ($1)
- Same collateral (staked ETH)
- Same interface (ERC20)
- Same liquidity pool
- Same redemption mechanism

Any protocol can integrate any other:
- Aave can accept UNI-$MUD as collateral
- Morpho can lend EIGEN-$MUD
- Uniswap pools need less liquidity (all $1)
- GMX can use any $MUD variant as margin

Built-in composability
No custom integrations needed
Instant interoperability

Network effects: N protocols → N² connections (all compatible)

5. Risk Management

Layered risk model:

Base layer (shared):

  • Staked ETH security
  • Ethereum consensus
  • Collateralization ratio
  • All variants equally exposed

Protocol layer (isolated):

  • Individual protocol risk
  • Smart contract risk
  • Operational risk
  • Only that variant exposed

Example risk scenario:

Morpho gets hacked:
- MORPHO-$MUD holders: Lose protocol yield (maybe)
- MORPHO-$MUD base value: Still $1 (staked ETH intact)
- Other variants: Completely unaffected
- Collateral pool: Still dynamically backed (adjusts to maintain peg)

Versus current model:
MORPHO token gets hacked:
- MORPHO holders: Lose everything (token price → 0)
- No base value protection
- Total loss possible

Risk reduction: Base value always protected, only yield at risk

Migration Path

Phase 1: Launch $MUD Base

Timeline: Q1 2025

1. Deploy base $MUD contract (with dynamic collateral manager)
2. Accept staked ETH deposits
3. Mint base $MUD (dynamic collateral ratio adjusts to market)
4. Establish $1 peg through redemption
5. Bootstrap liquidity ($100M+)

Participants: Early adopters, DeFi natives

Phase 2: First Protocol Variants

Timeline: Q2 2025

Launch 3-5 initial variants:
1. EIGEN-$MUD (restaking)
2. MORPHO-$MUD (optimized lending)
3. UNI-$MUD (trading fees)
4. AAVE-$MUD (lending)
5. CURVE-$MUD (stable swaps)

Each integrates with existing protocol
Starts earning protocol-specific yield
Maintains $1 stable base

Participants: Major DeFi protocols

Phase 3: Broad Adoption

Timeline: Q3-Q4 2025

Expand to 20-50 variants:
- All major lending protocols
- All major DEXs
- Derivatives platforms
- Liquid staking protocols
- New protocol launches

Liquidity converges into $MUD base
Users migrate from separate tokens
Capital efficiency improves

Participants: Entire DeFi ecosystem

Phase 4: Universal Standard

Timeline: 2026+

$MUD becomes default:
- New protocols launch as $MUD variants by default
- No more separate protocol tokens
- All share staked ETH collateral
- Unified DeFi monetary base
- Staked ETH = reserve currency
- $MUD variants = protocol currencies

Complete monetary convergence

Result: Staked ETH backs all of DeFi

Economic Implications

For Protocols

Benefits of launching as $MUD variant:

1. Instant liquidity:

  • Tap into shared $MUD liquidity pool
  • No need to bootstrap separate token liquidity
  • Users can trade immediately

2. Price stability:

  • No token price volatility
  • Users focus on protocol utility, not speculation
  • Sustainable growth (not pump-and-dump)

3. Capital efficiency:

  • Don’t need separate collateral
  • Share staked ETH security
  • Lower barriers to entry

4. Composability:

  • Instant integration with all other protocols
  • No custom integrations needed
  • Network effects from day one

5. User trust:

  • Backed by staked ETH (proven security)
  • $1 stable value (no rug risk)
  • Shared security model (collective defense)

Trade-off: Give up separate token speculation gains. But gain sustainable protocol revenue.

For Users

Benefits of using $MUD variants:

1. Simplicity:

  • One base currency ($MUD)
  • Multiple yield options (protocol variants)
  • Easy comparison (all $1 base)

2. Capital efficiency:

  • One collateral backs multiple positions
  • No need to buy multiple tokens
  • Lower capital requirements

3. Risk management:

  • Base value protected ($1 peg)
  • Protocol risks isolated
  • Diversification easier

4. Liquidity:

  • All variants share liquidity
  • Low slippage swaps
  • Instant rebalancing

5. Yield optimization:

  • Easy to compare yields
  • Simple to switch protocols
  • Compound rewards automatically

Result: Better user experience = more adoption = more protocol revenue

For DeFi Ecosystem

Systemic benefits:

1. Reduced fragmentation:

  • From 1000 separate tokens → 1000 $MUD variants
  • Unified monetary base
  • Shared liquidity
  • Capital efficiency

2. Staked ETH as reserve:

  • Universal collateral for all DeFi
  • Security scales with Ethereum
  • Decentralized backing
  • Growing over time

3. Sustainable growth:

  • Protocols compete on utility, not speculation
  • Revenue-focused, not token pump-focused
  • Long-term thinking
  • Ecosystem cooperation

4. Mainstream adoption:

  • Simpler for non-crypto natives
  • Stable base value (like dollars)
  • Clear yield products
  • Professional money can enter

5. Regulatory clarity:

  • $MUD variants more like yield products than securities
  • Backed by real collateral (staked ETH)
  • Transparent mechanics
  • Less regulatory risk

Result: DeFi grows 100×, reaches mainstream

Connection to Previous Posts

neg-518: Adaptive protocol fees.

$MUD variants would use adaptive fees. Each protocol variant charges 0-20% based on autonomy. Mature protocols like UNI-$MUD charge 18-20%. New protocols charge 0-2%. All track to maturity naturally.

neg-517: Dynamic collateralization.

$MUD uses dynamic collateral ratios. Ratio adjusts automatically based on volatility, liquidity, and debt. All variants share same dynamic collateral system. When ETH volatile, all ratios increase together. When calm, all decrease. Unified risk management. No hardcoded constants.

neg-516: $MUD implementation.

This is logical extension of $MUD. Not just one universal stablecoin, but family of protocol-specific variants. All backed by same staked ETH. All maintain $1 base. All add protocol yields. $MUD becomes base layer for all DeFi.

neg-515: Referential rupture.

DeFi USD (backed by staked ETH) defeats TradFi USD (backed by military force). $MUD variants are the implementation. Staked ETH becomes reserve currency. All protocols denominated in $MUD. This is the referential rupture made concrete.

neg-514: Distributed coordination.

Unified $MUD base enables better coordination. All protocols speak same monetary language. Liquidity flows freely. Information propagates instantly. Network effects multiply. Coordination defeats fragmentation.

neg-506: Agency bootstrap.

Users gain more agency with $MUD variants. Want (stable value + yield) → Can (choose any protocol variant) → Want’ (optimize yield across protocols). Agency loop enabled by unified monetary base.

The Formulation

Separate protocol tokens are not:

  • Capital efficient (each needs separate collateral)
  • Composable (different standards, different liquidity)
  • Stable (volatile token prices)
  • Simple (complex to manage multiple tokens)

Separate protocol tokens are:

  • Fragmented (1000+ isolated islands)
  • Inefficient (capital locked in silos)
  • Complex (overwhelming for users)
  • Speculative (price volatility dominates)

$MUD protocol variants are not:

  • Separate (all share base layer)
  • Volatile (stable $1 base value)
  • Complex (all same standard)
  • Fragmented (unified liquidity)

$MUD protocol variants are:

  • Unified (same staked ETH backing)
  • Stable ($1 base for all variants)
  • Composable (instant interoperability)
  • Capital efficient (shared collateral)
  • Universal (one monetary base for all DeFi)

The formula:

Old model:
Each protocol = Separate token
Each token = Own collateral
Each collateral = Isolated risk
Total complexity = N protocols × complexity
Result: Fragmentation

New model:
Each protocol = $MUD variant
All variants = Shared collateral (staked ETH)
All variants = Same base ($1 stable)
Each variant = Protocol-specific yield
Total complexity = 1 base + N yield options
Result: Convergence

Where:
Base: $MUD (staked ETH backed, $1 stable)
Variants: EIGEN-$MUD, MORPHO-$MUD, UNI-$MUD, etc.
Yield: Protocol-specific (restaking, lending, trading, etc.)
Liquidity: Unified (all share same pool)
Collateral: Shared (staked ETH for all)

The comparison:

Current DeFi:
Protocols: 1000
Tokens: 1000 (separate)
Collateral pools: 1000 (fragmented)
Liquidity: Split 1000 ways
Capital efficiency: 1/1000
Complexity: Overwhelming
Composability: Difficult

$MUD DeFi:
Protocols: 1000
Tokens: 1000 (but all $MUD variants)
Collateral pools: 1 (unified staked ETH)
Liquidity: Unified
Capital efficiency: 1000×
Complexity: Manageable
Composability: Automatic

Winner: $MUD variants on every dimension

The principle:

Every protocol token could just be $MUD variant.

Why separate tokens when can share base?
Why separate collateral when can pool risk?
Why separate liquidity when can unify?
Why fragment capital when can concentrate?

Answer: No reason.

Better model:
- One collateral (staked ETH)
- One base ($MUD at $1)
- Many variants (protocol-specific yields)
- Infinite composability
- Maximum capital efficiency
- Unified liquidity

This is monetary convergence.
This is the endgame.
This is inevitable.

Every protocol token becomes $MUD variant. Staked ETH backs everything. Unified DeFi monetary base. 🌀

#ProtocolTokenConvergence #MUDVariants #StakedETHBacking #UnifiedLiquidity #CapitalEfficiency #MonetaryUnification #DeFiEndgame #SharedCollateral #ComposabilityByDefault #TokenConvergence

Related: neg-518 (adaptive fees for all variants), neg-517 (dynamic collateral for all), neg-516 ($MUD base implementation), neg-515 (DeFi USD defeats TradFi USD), neg-514 (unified coordination), neg-506 (agency through unified base)

Back to Gallery
View source on GitLab