Trade Locked Yield

TL;DR: This guide shows you how to lock in a guaranteed Fixed Yield rate, protecting yourself from Variable Yield drops. You'll learn the complete flow from analysis to settlement.

When to Lock Fixed Yield

Lock FY when:

Scenario	Why Lock FY
VY is temporarily high	Capture the spike before rates normalize
You need predictable income	DAO treasury, personal budgeting
You're bearish on rates	Expect VY to drop
You want to hedge	Offset variable exposure elsewhere

Pre-Trade Analysis

Step 1: Check Current Rates

// Get current Fixed Yield from the pool
const [tick, sqrtPriceX96] = await vammManager.getVAMMState(poolId);
const currentFY = Math.pow(1.0001, Number(tick)) * 100;

// Get current Variable Yield from Aave
const currentVY = await aprOracle.getOnAprRay(aUSDC_ADDRESS);
const vyPercent = Number(currentVY) / 1e27 * 100;

console.log(`Current Fixed Yield:    ${currentFY.toFixed(2)}%`);
console.log(`Current Variable Yield: ${vyPercent.toFixed(2)}%`);

Analysis:

• If FY < VY: Locking FY costs you potential upside

• If FY > VY: Unusual — check why (may be opportunity or risk)

• FY ≈ VY: Market is balanced

Step 2: Calculate Break-Even

Your break-even is the VY rate where you neither profit nor lose:

Break-even VY = Your locked FY rate

Example:
- You lock: 6% FY
- If VY averages 4%: You profit 2%
- If VY averages 6%: Break even
- If VY averages 8%: You lose 2%

Step 3: Estimate PnL Scenarios

function calculatePnL(notional, termDays, lockedFY, actualVY) {
    const timeInYears = termDays / 365;
    const pnl = (lockedFY - actualVY) / 100 * notional * timeInYears;
    return pnl;
}

// Example scenarios
const notional = 100000;
const termDays = 90;
const lockedFY = 6;

console.log("Scenario Analysis:");
console.log(`VY = 3%: PnL = $${calculatePnL(notional, termDays, lockedFY, 3).toFixed(2)}`);
console.log(`VY = 6%: PnL = $${calculatePnL(notional, termDays, lockedFY, 6).toFixed(2)}`);
console.log(`VY = 9%: PnL = $${calculatePnL(notional, termDays, lockedFY, 9).toFixed(2)}`);

Output:

Scenario Analysis:
VY = 3%: PnL = $739.73
VY = 6%: PnL = $0.00
VY = 9%: PnL = $-739.73

Opening the Position

Step 1: Ensure Sufficient Margin

// Check current margin
const currentMargin = await collateralEngine.getAccountMargin(account, USDC);

// Estimate required margin (rule of thumb: 5-10% of notional)
const notional = ethers.parseUnits("100000", 6);
const estimatedMargin = notional / 10n;  // 10%

if (currentMargin < estimatedMargin) {
    // Deposit more margin
    const toDeposit = estimatedMargin - currentMargin;
    await usdc.approve(COLLATERAL_ENGINE, toDeposit);
    await collateralEngine.updateAccountMargin(account, USDC, toDeposit);
    console.log(`Deposited ${ethers.formatUnits(toDeposit, 6)} USDC`);
}

Step 2: Execute the Swap

const MIN_SQRT_RATIO = 4295128739n;
const MIN_TICK = -887270;
const MAX_TICK = 887270;

// Lock Fixed Yield = NEGATIVE amountSpecified
const notional = ethers.parseUnits("100000", 6);

const tx = await vammManager.swap(
    [
        poolKey.underlyingAsset,
        poolKey.compoundToken,
        poolKey.termStartTimestampWad,
        poolKey.termEndTimestampWad,
        poolKey.feeWad,
        poolKey.tickSpacing
    ],
    {
        account: [account.owner, account.id, account.isolatedMarginToken],
        amountSpecified: -notional,  // NEGATIVE = Lock Fixed Yield
        sqrtPriceLimitX96: MIN_SQRT_RATIO + 1n,  // Min price (max FY we'd accept)
        tickLower: MIN_TICK,
        tickUpper: MAX_TICK
    }
);

const receipt = await tx.wait();
console.log("Transaction confirmed:", receipt.hash);

Step 3: Parse the Result

// The swap returns multiple values
const [
    fixedTokenDelta,      // Your fixed token balance change
    variableTokenDelta,   // Your variable token balance change
    cumulativeFeeIncurred, // Fees paid
    fixedTokenDeltaUnbalanced,
    positionMarginRequirement  // Required margin after trade
] = await vammManager.swap.staticCall(...params);

// Calculate effective FY locked
const effectiveFY = /* derive from tick after swap */;

console.log("Position Opened:");
console.log(`Fixed Token Delta: ${fixedTokenDelta}`);
console.log(`Variable Token Delta: ${variableTokenDelta}`);
console.log(`Fee Paid: ${ethers.formatUnits(cumulativeFeeIncurred, 6)} USDC`);
console.log(`Margin Required: ${ethers.formatUnits(positionMarginRequirement, 6)} USDC`);

Understanding Your Position

Position Breakdown

FY Position Summary:
━━━━━━━━━━━━━━━━━━━━

fixedTokenBalance: +100,000
  → You RECEIVE 100,000 USDC worth of Fixed Yield

variableTokenBalance: -100,000
  → You GIVE UP 100,000 USDC worth of Variable Yield

Net at settlement:
  cashflow = fixedTokens × fixedFactor + variableTokens × variableFactor
  cashflow = 100,000 × (FY × time) + (-100,000) × (VY × time)
  cashflow = 100,000 × (FY - VY) × time

What the Numbers Mean

If	Then	Outcome
VY < FY	Cashflow positive	You profit
VY = FY	Cashflow zero	Break even
VY > FY	Cashflow negative	You lose

Monitoring Your Position

Check Unrealized PnL

async function getUnrealizedPnL(account, poolKey) {
    // Get current variable factor (VY accrued so far)
    const currentTimestamp = Math.floor(Date.now() / 1000);
    const termStart = Number(poolKey.termStartTimestampWad / 10n**18n);
    
    const [variableFactor, valid] = await aprOracle.getRateFromTo(
        poolKey.compoundToken,
        termStart,
        currentTimestamp
    );
    
    // Get fixed factor for elapsed time
    const elapsedTime = currentTimestamp - termStart;
    const fixedFactor = elapsedTime / (365 * 24 * 3600) / 100;
    
    // Get position balances (simplified)
    const fixedTokens = 100000;  // Your position
    const variableTokens = -100000;
    
    // Calculate unrealized PnL
    const unrealizedPnL = fixedTokens * fixedFactor + 
                          variableTokens * Number(variableFactor) / 1e18;
    
    return unrealizedPnL;
}

Check Health Factor

async function checkHealth(account) {
    // This will revert if margin is insufficient
    try {
        const marginReq = await collateralEngine.checkMarginRequirement(account);
        console.log(`Margin Requirement: ${ethers.formatUnits(marginReq, 6)} USDC`);
        console.log("Position is healthy ✓");
    } catch (error) {
        console.log("Position may be at risk! Check margin.");
    }
}

Closing Early (Optional)

If you want to exit before maturity:

// Close FY position = open opposite VY position
// POSITIVE amountSpecified closes your FY position

const notionalToClose = ethers.parseUnits("100000", 6);

await vammManager.swap(
    poolKeyArray,
    {
        account: accountTuple,
        amountSpecified: notionalToClose,  // POSITIVE = close FY
        sqrtPriceLimitX96: MAX_SQRT_RATIO - 1n,
        tickLower: MIN_TICK,
        tickUpper: MAX_TICK
    }
);

console.log("Position closed early");

Note: Closing early may result in slippage and you realize current PnL immediately.

Settlement at Maturity

When Pool Matures

// Check if pool has matured
const currentTime = BigInt(Math.floor(Date.now() / 1000)) * 10n**18n;
const maturityTime = poolKey.termEndTimestampWad;

if (currentTime >= maturityTime) {
    console.log("Pool has matured! Ready to settle.");
} else {
    const remaining = Number(maturityTime - currentTime) / 1e18 / 86400;
    console.log(`${remaining.toFixed(1)} days until maturity`);
}

Execute Settlement

await collateralEngine.settlePosition(account, poolKey);

// Check final margin balance
const finalBalance = await collateralEngine.getAccountMargin(account, USDC);
console.log(`Final USDC Balance: ${ethers.formatUnits(finalBalance, 6)}`);

Complete Example

import { ethers } from "ethers";

// Configuration
const CONFIG = {
    VAMM_MANAGER: "0xe8FE9b71355B1701036671AD3c8F6dF585eb7eBd",
    COLLATERAL_ENGINE: "0x23E2DD3bB6e35162eB48d473d540764d5902BAe5",
    USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
    aUSDC: "0xA4D94019934D8333Ef880ABFFbF2FDd611C762BD"
};

async function lockFixedYield(signer, notionalUsdc) {
    // 1. Setup contracts
    const vammManager = new ethers.Contract(CONFIG.VAMM_MANAGER, VAMM_ABI, signer);
    const collateralEngine = new ethers.Contract(CONFIG.COLLATERAL_ENGINE, CE_ABI, signer);
    
    // 2. Setup account
    const account = {
        owner: await signer.getAddress(),
        id: 0,
        isolatedMarginToken: ethers.ZeroAddress
    };
    
    // 3. Deposit margin (10% of notional)
    const margin = ethers.parseUnits(String(notionalUsdc / 10), 6);
    await collateralEngine.updateAccountMargin(account, CONFIG.USDC, margin);
    
    // 4. Execute swap to lock FY
    const notional = ethers.parseUnits(String(notionalUsdc), 6);
    await vammManager.swap(
        poolKeyArray,
        {
            account: [account.owner, account.id, account.isolatedMarginToken],
            amountSpecified: -notional,  // NEGATIVE = Lock FY
            sqrtPriceLimitX96: MIN_SQRT_RATIO + 1n,
            tickLower: MIN_TICK,
            tickUpper: MAX_TICK
        }
    );
    
    console.log(`Locked Fixed Yield on ${notionalUsdc} USDC!`);
}

// Usage
await lockFixedYield(signer, 100000);  // Lock FY on 100k USDC

Key Takeaways

1. Negative amountSpecified = Lock Fixed Yield

2. Check rates first — Understand FY vs VY before trading

3. Maintain margin buffer — Don't use maximum leverage

4. Monitor position — Check health factor regularly

5. Settle at maturity — Collect your PnL

Next Steps

• Trade Variable Yield — The opposite position

• Settlement — Maturity process details

• Risk Management — Managing your risks