DeFi Yield Aggregation: Maximizing Returns in Decentralized Finance

Yield aggregation is one of the most practical applications of DeFi composability. Instead of manually moving funds between protocols, aggregators automate this process to maximize returns. Let me share insights from building one.

What is Yield Aggregation?

Yield aggregation involves:

1. Monitoring yields across multiple DeFi protocols
2. Automatically allocating funds to highest-yielding opportunities
3. Compounding rewards to maximize returns
4. Managing risk through diversification

Architecture Overview

┌─────────────────────────────────────────────────┐
│              Yield Aggregator                    │
├─────────────────────────────────────────────────┤
│  Strategy Manager  │  Risk Engine  │  Executor  │
├─────────────────────────────────────────────────┤
│           Protocol Adapters Layer                │
├─────────────────────────────────────────────────┤
│  Aave  │  Compound  │  Curve  │  Yearn  │  ...  │
└─────────────────────────────────────────────────┘

TypeScript Implementation

Protocol Interface

interface YieldProtocol {
  name: string;
  address: string;

  // Get current APY
  getAPY(): Promise<number>;

  // Get total value locked
  getTVL(): Promise<bigint>;

  // Deposit funds
  deposit(amount: bigint): Promise<TransactionReceipt>;

  // Withdraw funds
  withdraw(amount: bigint): Promise<TransactionReceipt>;

  // Harvest rewards
  harvest(): Promise<bigint>;
}

Strategy Manager

class StrategyManager {
  private protocols: Map<string, YieldProtocol>;
  private allocations: Map<string, number>;

  async rebalance(): Promise<void> {
    // 1. Calculate optimal allocation
    const optimal = await this.calculateOptimalAllocation();

    // 2. Determine required moves
    const moves = this.calculateMoves(this.allocations, optimal);

    // 3. Execute withdrawals first
    for (const move of moves.filter(m => m.amount < 0)) {
      await this.protocols.get(move.protocol)!
        .withdraw(BigInt(Math.abs(move.amount)));
    }

    // 4. Execute deposits
    for (const move of moves.filter(m => m.amount > 0)) {
      await this.protocols.get(move.protocol)!
        .deposit(BigInt(move.amount));
    }

    this.allocations = optimal;
  }

  private async calculateOptimalAllocation(): Promise<Map<string, number>> {
    const protocolData = await Promise.all(
      Array.from(this.protocols.entries()).map(async ([name, protocol]) => ({
        name,
        apy: await protocol.getAPY(),
        tvl: await protocol.getTVL(),
        riskScore: this.assessRisk(protocol),
      }))
    );

    // Risk-adjusted return optimization
    return this.optimizeAllocation(protocolData);
  }
}

Risk Management

Risk Factors to Consider

1. Smart Contract Risk: Has the protocol been audited?
2. Protocol Risk: TVL trends, team reputation
3. Market Risk: Impermanent loss for LP positions
4. Liquidity Risk: Can we exit positions quickly?

Risk Scoring

interface RiskAssessment {
  contractRisk: number;  // 0-100
  protocolRisk: number;
  marketRisk: number;
  liquidityRisk: number;
}

function calculateRiskScore(assessment: RiskAssessment): number {
  const weights = {
    contractRisk: 0.4,
    protocolRisk: 0.3,
    marketRisk: 0.2,
    liquidityRisk: 0.1,
  };

  return Object.entries(weights).reduce(
    (score, [key, weight]) =>
      score + assessment[key as keyof RiskAssessment] * weight,
    0
  );
}

Gas Optimization

Gas costs can eat into yields significantly. Strategies include:

Batching Transactions

async function batchHarvest(protocols: YieldProtocol[]): Promise<void> {
  const multicall = new Multicall({ ethersProvider: provider });

  const calls = protocols.map(p => ({
    target: p.address,
    callData: p.interface.encodeFunctionData('harvest'),
  }));

  await multicall.aggregate(calls);
}

Optimal Harvest Timing

function shouldHarvest(
  pendingRewards: bigint,
  gasPrice: bigint,
  estimatedGas: bigint
): boolean {
  const gasCost = gasPrice * estimatedGas;
  const rewardsInEth = convertToEth(pendingRewards);

  // Only harvest if rewards > 2x gas cost
  return rewardsInEth > gasCost * 2n;
}

Auto-Compounding

The power of compound interest in DeFi:

async function autoCompound(): Promise<void> {
  // 1. Harvest all rewards
  const rewards = await harvestAll();

  // 2. Swap rewards to base token
  const baseAmount = await swapToBase(rewards);

  // 3. Redeposit
  await rebalance();

  // Log APY improvement
  console.log(`Compounded ${formatUnits(rewards)} tokens`);
}

Challenges and Solutions

Impermanent Loss

For LP positions, track IL and factor it into return calculations:

function calculateNetReturn(
  lpReturn: number,
  impermanentLoss: number
): number {
  return lpReturn - impermanentLoss;
}

MEV Protection

Use private mempools or flashbots to avoid front-running:

const flashbotsProvider = await FlashbotsBundleProvider.create(
  provider,
  authSigner
);

Conclusion

Building a yield aggregator taught me that DeFi is as much about risk management as it is about maximizing returns. The best aggregators balance yield optimization with robust risk controls.

The composability of DeFi means we can build sophisticated financial instruments, but it also means risks can cascade across protocols. Always factor in the full risk picture when chasing yield.