How it Works?

How SaucerHedge Works

Strategy Overview

SaucerHedge combines concentrated liquidity provision with automated hedging to protect against impermanent loss while earning trading fees.

User Deposits 1000 USDC + 10 HBAR
              │
              ├─→ 79% → SaucerSwap V2 LP Position
              │         ├─ Concentrated liquidity (custom tick range)
              │         ├─ Earn trading fees from swaps
              │         └─ Auto-compound rewards via Vincent
              │
              └─→ 21% → Bonzo Finance Short Position
                        ├─ Borrow HBAR using flash loan
                        ├─ Sell borrowed HBAR for USDC
                        ├─ Hedge against HBAR price decline
                        └─ Rebalance based on IL metrics

All actions executed by Vincent abilities within your defined scope
All transactions recorded on Hedera Consensus Service
You maintain full control via PKP permissions

The Hedging Mechanism

Step-by-Step Process

1. Position Opening

When you deposit assets, SaucerHedge calculates the optimal allocation:

// Pseudocode for position calculation
function calculatePositions(userDeposit, priceRange) {
  // Calculate LP amounts using Uniswap V3 math
  const lpAllocation = userDeposit * 0.79;
  const [token0Amount, token1Amount] = calculateConcentratedLP(
    lpAllocation, 
    priceRange
  );
  
  // Calculate hedge amount to offset IL
  const hedgeAmount = calculateOptimalHedge(
    token0Amount,
    token1Amount,
    priceRange
  );
  
  return {
    lpPosition: { token0Amount, token1Amount },
    shortPosition: hedgeAmount,
    collateral: userDeposit * 0.21
  };
}

2. Opening LP Position

Vincent's HederaLPManagerAbility executes:

// Simplified contract interaction
function openLPPosition(
    address token0,
    address token1,
    uint24 fee,
    int24 tickLower,
    int24 tickUpper,
    uint256 amount0,
    uint256 amount1
) external returns (uint256 tokenId, uint128 liquidity) {
    // Approve SaucerSwap V2 to spend tokens
    IERC20(token0).approve(SAUCERSWAP_POSITION_MANAGER, amount0);
    IERC20(token1).approve(SAUCERSWAP_POSITION_MANAGER, amount1);
    
    // Mint concentrated liquidity position
    (tokenId, liquidity, ,) = ISaucerSwapV2(SAUCERSWAP_POSITION_MANAGER)
        .mint(MintParams({
            token0: token0,
            token1: token1,
            fee: fee,
            tickLower: tickLower,
            tickUpper: tickUpper,
            amount0Desired: amount0,
            amount1Desired: amount1,
            amount0Min: amount0 * 95 / 100, // 5% slippage
            amount1Min: amount1 * 95 / 100,
            recipient: address(this),
            deadline: block.timestamp + 300
        }));
}

3. Opening Short Position

Vincent's HederaHedgeAbility executes via Bonzo Finance:

function openShortPosition(
    address asset,
    uint256 amount,
    address collateralAsset,
    uint256 collateralAmount
) external returns (uint256 positionId) {
    // 1. Use flash loan from Bonzo for gas efficiency
    IBonzo(BONZO_LENDING_POOL).flashLoan(
        address(this),
        asset,
        amount,
        abi.encode(collateralAsset, collateralAmount)
    );
    
    // In the flashloan callback:
    // 2. Sell borrowed asset for stablecoin
    uint256 stableReceived = swap(asset, USDC, amount);
    
    // 3. Deposit collateral to Bonzo
    IBonzo(BONZO_LENDING_POOL).deposit(
        collateralAsset,
        collateralAmount,
        address(this)
    );
    
    // 4. Maintain debt position
    // Flash loan automatically manages debt
}

4. Position Monitoring

Vincent continuously monitors IL metrics:

// Simplified monitoring logic
async function monitorPosition(positionId) {
  while (positionActive) {
    // Get current state
    const currentPrice = await oracle.getPrice(HBAR_USDC);
    const lpValue = await calculateLPValue(positionId, currentPrice);
    const holdValue = calculateHoldValue(initialDeposit, currentPrice);
    
    // Calculate IL
    const impermanentLoss = holdValue - lpValue;
    const ilPercentage = (impermanentLoss / initialDeposit) * 100;
    
    // Check if rebalance needed
    if (ilPercentage > REBALANCE_THRESHOLD) {
      await rebalancePosition(positionId);
    }
    
    // Check if price exceeded hedge range
    if (currentPrice < lowerBound || currentPrice > upperBound) {
      await closePosition(positionId); // Trigger hook
    }
    
    await sleep(MONITORING_INTERVAL);
  }
}

5. Automatic Rebalancing

When IL deviates from target:

function rebalanceHedge(
    uint256 positionId,
    int256 adjustment
) external onlyVincentAbility {
    Position memory position = positions[positionId];
    
    if (adjustment > 0) {
        // Increase hedge (IL rising)
        increaseShortPosition(
            position.hedgeId,
            uint256(adjustment)
        );
    } else if (adjustment < 0) {
        // Decrease hedge (IL falling)
        decreaseShortPosition(
            position.hedgeId,
            uint256(-adjustment)
        );
    }
    
    // Log to Hedera Consensus Service
    logRebalance(positionId, adjustment, block.timestamp);
}

Mathematical Foundation

Concentrated Liquidity Equations

Based on Uniswap V3 (used by SaucerSwap V2):

Liquidity Formula:

L = Δy / (√P - √Pa)
L = Δx × √P × √Pb / (√Pb - √P)

Where:

• L = Virtual liquidity

• Δx = Amount of token0 (e.g., HBAR)

• Δy = Amount of token1 (e.g., USDC)

• P = Current price

• Pa = Lower price bound

• Pb = Upper price bound

Position Value Calculation:

At current price P:

x = L × (√Pb - √P) / (√P × √Pb)
y = L × (√P - √Pa)
Value = x × P + y

At lower bound Pa:

x_lower = L × (√Pb - √Pa) / (√Pa × √Pb)
y_lower = 0
Value_lower = x_lower × Pa

At upper bound Pb:

x_upper = 0
y_upper = L × (√Pb - √Pa)
Value_upper = y_upper

Hedge Ratio Calculation

The optimal short amount to offset IL:

Short Amount (s) = P × (Value_upper - Value_lower) / (Pb - Pa)

This formula ensures that gains/losses from the short position offset the impermanent loss across the price range.

Example Calculation:

Given:

• Initial value: $1,000

• Price range: $900 - $1,100 HBAR/USDC

• Current price: $1,000

• Leverage: 2x

1. Calculate LP amounts:
   x = 1000 / ((√1000 - √900)/(√1100 - √1000) × √1000 × √1100 + 1000)
   x ≈ 0.39 HBAR
   y = 1000 - 0.39 × 1000 = 610 USDC
   L = y / (√1000 - √900) ≈ 192.45

2. Calculate value at bounds:
   Value_lower = L × (√1100 - √900) / (√900 × √1100) × 900 ≈ $925.5
   Value_upper = L × (√1100 - √900) ≈ $1,023.2

3. Calculate hedge amount:
   s = 1000 × (1023.2 - 925.5) / (1100 - 900)
   s ≈ 0.49 HBAR to short

4. Adjust for deployment:
   Total needed = LP (790) + Collateral (210) = 1000
   x_adjusted = 0.39 × (790 / (0.39 × 1000 + 610 + 0.49/2))
   y_adjusted = 610 × (790 / (0.39 × 1000 + 610 + 0.49/2))
   s_adjusted = 0.49 × (790 / (0.39 × 1000 + 610 + 0.49/2))

Why 79% / 21% Split?

This ratio is derived from:

Hedge Collateral Ratio = Short Amount / (Leverage × LP Value)
                       ≈ 0.21 (21% of total capital)
LP Allocation = 1 - Hedge Collateral Ratio
              = 0.79 (79% of total capital)

This ensures:

• Sufficient collateral to avoid liquidation

• Maximum capital efficiency

• Optimal IL protection

Performance Comparison

Without SaucerHedge

Scenario: HBAR drops 20% ($1000 → $800)

LP Position:
- Initial: 10 HBAR + $10,000 USDC
- After: ~11.18 HBAR + $8,944 USDC
- Value: $17,888
- Loss: -$2,112 (-10.6%)

Trading Fees (30 days @ 30% APY):
- Fee income: ~$492
- Net loss: -$1,620 (-8.1%)

With SaucerHedge

Same Scenario: HBAR drops 20%

LP Position (79% of capital):
- Value: $14,131
- IL: ~$1,669

Short Position (21% as collateral):
- Short: 1.97 HBAR
- Entry price: $1,000
- Exit price: $800
- Profit: 1.97 × $200 = $394

But with 2x leverage on the short:
- Effective profit: $394 × 2 = $788

Trading Fees (from LP):
- Fee income: ~$389

Net Result:
- LP loss: -$1,669
- Short gain: +$788  
- Trading fees: +$389
- Net: -$492 (-2.5%)

Improvement: 5.6% better than unhedged!

Vincent Delegation Flow

1. Wallet Connection

User → HashPack/Kabila/MetaMask Snap
     → SaucerHedge Frontend
     → Wallet connected

2. PKP Vault Creation

User → Request PKP creation
     → Lit Protocol generates PKP
     → Non-custodial wallet created
     → User controls via private key signatures

3. Delegation Scope Configuration

const delegationScope = {
  // Allowed contracts
  allowedContracts: [
    SAUCERHEDGER_ADDRESS,
    SAUCERSWAP_V2_ADDRESS,
    BONZO_FINANCE_ADDRESS
  ],
  
  // Allowed functions
  allowedFunctions: [
    'openHedgedLP',
    'rebalance',
    'closePosition',
    'collectFees'
  ],
  
  // Transaction limits
  maxTransactionAmount: parseUnits('5000', 6), // 5000 USDC
  dailyLimit: parseUnits('20000', 6),
  
  // Approval thresholds
  requiresApprovalAbove: parseUnits('10000', 6),
  
  // Time constraints
  minTimeBetweenTx: 300, // 5 minutes
  
  // Emergency controls
  pausable: true,
  emergencyWithdrawal: true
};

4. Asset Deposit

User → Approve tokens to Vincent Vault
     → Deposit HBAR + USDC
     → Assets in non-custodial PKP vault
     → User retains ownership

5. Strategy Execution

Vincent Abilities → Check delegation scope
                 → Execute within permissions
                 → Log to Hedera Consensus Service
                 → Continue monitoring

6. Ongoing Management

Vincent → Monitor IL metrics
       → Check price vs hedge range
       → Rebalance if needed (within scope)
       → Collect and compound fees
       → Alert user if approval needed

7. User Control

User can at any time:
- Modify delegation scope
- Pause automation
- Withdraw funds
- Revoke Vincent permissions
- View full audit trail on HCS

Consensus Service Audit Trail

Every action is logged immutably:

{
  "timestamp": "2025-10-23T14:32:00Z",
  "positionId": "0x1234...",
  "action": "openHedgedLP",
  "details": {
    "lpTokenId": 42,
    "lpValue": "15800.00 USDC",
    "shortAmount": "1.97 HBAR",
    "hedgeRatio": "21%",
    "priceRange": {
      "lower": "900 USDC",
      "upper": "1100 USDC"
    }
  },
  "txHash": "0xabcd...",
  "consensusTimestamp": "1729693920.000000000"
}

Users can query the audit trail to verify all actions taken by Vincent abilities.

Key Advantages

1. Non-Custodial - Assets never leave your control

2. Transparent - All actions on-chain and logged to HCS

3. Automated - No manual intervention needed

4. Cost-Effective - Hedera's low fees (~$0.0001)

5. MEV-Resistant - Fair ordering on Hedera

6. Capital Efficient - 79% LP, 21% collateral

7. Risk-Controlled - Defined delegation scope