Detailed Instructions

First, select the underlying asset for your strategy, such as ETH. The goal is to hedge the delta (price sensitivity) of a spot holding. Calculate the hedge ratio, which is typically 1:1 for a perfect hedge, meaning for every 1 ETH held spot, you need a short position equivalent to 1 ETH in perpetual futures. However, adjust this ratio if using leveraged positions or targeting a specific net delta. Determine the notional value of your spot position (e.g., 10 ETH * $3,000 = $30,000). This notional value dictates the size of your futures short.

• Sub-step 1: Calculate spot position notional value: Position Value = Token Amount * Current Market Price
• Sub-step 2: Set target delta to zero: Target Delta = 0
• Sub-step 3: Determine futures position size: Futures Size = -(Spot Notional Value) / Futures Price

Tip: For assets with high funding rates, consider a slightly asymmetric hedge ratio to capture positive funding while remaining delta-neutral.

Detailed Instructions

With the calculated size, open a short position on a platform like GMX, dYdX, or Perpetual Protocol. Connect your wallet (e.g., MetaMask) to the protocol's front-end. You will need sufficient collateral, often in a stablecoin like USDC, to post margin. Select the correct market (e.g., ETH-PERP) and choose order type. A market order executes immediately but may incur slippage; a limit order provides price control. Input the short size, ensuring it matches your calculated notional hedge. Review the initial margin requirement and liquidation price before confirming.

• Sub-step 1: Deposit collateral (e.g., 5,000 USDC) into the protocol's margin account.
• Sub-step 2: On the trading interface, select 'Sell' or 'Short' for the ETH perpetual market.
• Sub-step 3: Enter order size (e.g., -10 ETH equivalent) and confirm transaction, paying gas and any protocol fees.

javascriptCopy
// Example pseudo-interaction for opening a short on a typical DEX
const shortTx = await perpContract.openPosition({
  isLong: false,
  collateralDelta: ethers.utils.parseUnits('5000', 6), // USDC
  sizeDelta: ethers.utils.parseUnits('10', 18) // 10 ETH notional
});

Tip: Monitor the opening price and immediate funding rate; entering when funding is positive means you pay shorts, which is a cost for this hedge.

Detailed Instructions

Delta neutrality decays over time due to price drift and funding rate payments. The spot ETH price and the perpetual futures price will not move in perfect lockstep, creating basis risk. You must periodically check the net delta of your combined position. Use a portfolio tracker or calculate manually: Net Delta = Spot Delta + Futures Delta. The futures delta for a short is negative. If the net delta moves beyond a threshold (e.g., ±0.1 ETH), you must rebalance. This involves adjusting the futures position size via increasing the short or adding a small long to correct.

• Sub-step 1: Daily, query spot price from an oracle and mark price from the perpetual exchange.
• Sub-step 2: Calculate current deltas: Spot Delta = 10 ETH, Futures Delta = -9.95 ETH (if price moved).
• Sub-step 3: Execute a rebalancing trade: Open an additional short of 0.05 ETH notional to return net delta to zero.

Tip: Automate monitoring with scripts or use DeFi management platforms that offer delta dashboards to alert you when rebalancing is needed.

Detailed Instructions

Perpetual futures use a funding rate mechanism to tether the contract price to the spot index. This rate is paid between traders every 1-8 hours, typically. As the holder of a short position, you will receive funding when the rate is positive (more longs than shorts) and pay funding when it is negative. These cash flows are separate from PnL and directly affect your strategy's yield. Track the funding rate history for your asset. Your hedge's profitability may come from consistently positive funding accrual. Factor these payments into your collateral management to avoid unexpected margin draws.

• Sub-step 1: Check the current and predicted funding rate on the exchange's data page.
• Sub-step 2: Calculate periodic payment: Funding Payment = Position Size * Funding Rate.
• Sub-step 3: If paying funding, ensure sufficient stablecoin collateral remains above maintenance margin.

solidityCopy
// Conceptual view of a funding payment calculation in a smart contract
// fundingRate can be positive or negative
int256 fundingPayment = (positionSize * fundingRate) / PRECISION;
// If fundingPayment > 0, short receives payment. If < 0, short pays.

Tip: During periods of extreme bullish sentiment, funding rates can turn highly positive, making short hedges profitable from funding alone.

Detailed Instructions

To exit the delta-neutral position, you must close both the spot holding and the perpetual short. The order can matter due to temporary delta exposure. The standard method is to execute near-simultaneously. First, close the perpetual short by opening an offsetting long position of the exact same size on the same exchange. This action locks in the PnL from the futures hedge, which will be the inverse of the spot price movement plus cumulative funding. Then, sell your spot ETH on a DEX or CEX. Calculate final profitability: Total PnL = (Spot Sale PnL) + (Futures PnL) + (Net Funding Received).

• Sub-step 1: On the perp exchange, open a long position with size equal to your existing short (e.g., +10 ETH notional).
• Sub-step 2: Confirm the short position is closed and all margin collateral is withdrawn.
• Sub-step 3: Swap your 10 ETH for USDC on Uniswap using a limit order to minimize slippage.

Tip: Consider using a TWAP (Time-Weighted Average Price) order for the spot sale to reduce market impact, especially for large positions.

Detailed Instructions

Funding rate arbitrage is the primary profit mechanism. You must track the funding rate on your long and short perpetual positions across different protocols (e.g., GMX, dYdX, Perpetual Protocol). The basis, or price difference between the perpetual and its underlying spot index, is a leading indicator for funding rate changes.

• Sub-step 1: Use a data aggregator like Coinalyze, Parsec, or a custom subgraph to pull real-time funding rates for your asset pairs.
• Sub-step 2: Calculate the net funding rate you are earning or paying. For example, if long pays -0.01% and short receives +0.02%, your net yield is +0.03% per funding interval.
• Sub-step 3: Set up alerts for when the basis widens beyond a threshold (e.g., >1%), signaling potential funding rate shifts or market dislocation.

javascriptCopy
// Example: Fetching funding rate from a hypothetical API
const longFunding = await gmxVault.getFundingRate('ETH');
const shortFunding = await perpProtocol.currentFundingRate('ETH');
const netFundingYield = shortFunding - longFunding;
console.log(`Net Funding Yield: ${netFundingYield}%`);

Tip: Funding is typically paid every 1-8 hours. Factor in gas costs when calculating net profitability for frequent rebalancing.

Detailed Instructions

Health Factor and Margin Ratio are critical metrics. A delta-neutral setup involves multiple leveraged positions, each with its own liquidation price. Your overall strategy can fail if one leg gets liquidated due to isolated price movement or funding accruals changing your collateral balance.

• Sub-step 1: Check the health factor for each position individually. On Aave/Compound for your long leg, ensure it's >1.5. On GMX or dYdX, verify your margin remains above the maintenance threshold.
• Sub-step 2: Account for cross-margin effects. If you're using the same collateral pool (e.g., USDC in your GMX account for multiple positions), a loss on one trade reduces margin for all.
• Sub-step 3: Simulate worst-case scenarios. Calculate the price move that would trigger liquidation on your most vulnerable leg, considering potential spikes in volatility and on-chain oracle latency.

solidityCopy
// Pseudocode for checking a GMX position health
function checkGMXPosition(address positionKey) public view returns (bool isSafe) {
    (uint256 size, uint256 collateral, uint256 entryPrice, ) = vault.getPosition(positionKey);
    uint256 liqPrice = calculateLiquidationPrice(size, collateral, entryPrice);
    isSafe = (getOraclePrice() * 100 / liqPrice) > 105; // 5% buffer
}

Tip: Use a dashboard like DeBank or Zapper to aggregate your positions, but always verify key calculations on-chain.

Detailed Instructions

Delta drift occurs as the prices of your long and short assets diverge or as funding payments alter your collateral amounts. Rebalancing involves depositing/withdrawing collateral or adjusting notional sizes to return your net delta to zero.

• Sub-step 1: Calculate your current net delta. Sum the delta of all positions (Long Delta = +1 per unit, Short Delta = -1 per unit). A simple ETH position: Long 10 ETH on Aave (+10), Short 9.8 ETH on Perp Protocol (-9.8) = Net Delta +0.2.
• Sub-step 2: Determine the rebalancing action. To neutralize +0.2 delta, you could increase your short position by 0.2 ETH notional or decrease your long position.
• Sub-step 3: Execute the rebalance on-chain. This may involve a swap to add collateral to the short side or a withdrawal and repay on the long side. Always factor in transaction costs.

pythonCopy
# Example Python logic for calculating net delta
def calculate_net_delta(positions):
    net_delta = 0
    for pos in positions:
        if pos['side'] == 'long':
            net_delta += pos['size']
        else:
            net_delta -= pos['size']
    return net_delta

# If net_delta is 0.5, you are net long and need to increase your short exposure.

Tip: Automate rebalancing with a keeper bot or Gelato Network, but include strict delta bounds (e.g., rebalance when |net delta| > 0.1) to avoid excessive gas expenditure.

Detailed Instructions

Smart contract risk is non-diversifiable. Your strategy depends on the security of multiple protocols. Stay informed on governance proposals, parameter updates (like liquidation penalties or funding rate caps), and any audit findings.

• Sub-step 1: Track governance forums and announcement channels for all integrated protocols (e.g., Aave Governance, GMX Governance, dYdX Twitter).
• Sub-step 2: Monitor for unusual on-chain activity. Use a service like Tenderly or Forta to set up alerts for large withdrawals from protocol treasuries or unexpected contract calls to your position addresses.
• Sub-step 3: Have an exit plan. Know the withdrawal process for each protocol and keep a portion of gas funds readily available in a separate wallet to execute an emergency unwind if a critical vulnerability is announced.

bashCopy
# Example: Using Forta alert configuration snippet for monitoring a vault
{
  "type": "FORTA_ALERT",
  "address": "0x489ee077994B6658eAfA855C308275EAd8097C4A", # GMX Vault
  "event": "Withdraw",
  "threshold": "100000000000000000000000", # Alert on 100k+ USDC withdraw
}

Tip: Consider using decentralized insurance cover from protocols like Nexus Mutual or Sherlock for specific smart contract risks, though coverage terms are strict.

Detailed Instructions

Net Annual Percentage Yield (APY) must account for all costs: funding rate differentials, borrowing interest on long legs, gas fees for rebalancing, and any slippage. Performance analysis is not just about raw yield but risk-adjusted return on capital deployed.

• Sub-step 1: Log all transactions. Record every deposit, withdrawal, rebalance, and funding payment with timestamps, amounts, and gas costs (in USD at time of tx).
• Sub-step 2: Calculate your true P&L. Sum all cash flows: (Funding Received - Funding Paid) + (Trading P&L from rebalancing) - (Borrow Interest) - (Total Gas Costs in USD).
• Sub-step 3: Optimize transaction timing. Schedule rebalances during periods of low base fee (e.g., weekends, UTC night) and consider using Layer 2 solutions if protocols are available (e.g., Perpetual Protocol on Optimism).

javascriptCopy
// Example structure for a transaction log entry
const txLog = {
  timestamp: 1678886400,
  type: 'rebalance',
  asset: 'ETH',
  amount: 0.5,
  gasUsed: 150000,
  gasPriceGwei: 45,
  ethPriceUSD: 1800,
  gasCostUSD: (150000 * 45e9 * 1800) / 1e18
};

Tip: Use a gas estimation tool like Blocknative or Etherscan's Gas Tracker to set dynamic gas prices for your automated transactions, avoiding overpayment during calm periods.