Understanding Mark Price vs Index Price in Perp Trading

Detailed Instructions

The funding rate mechanism is triggered by the price premium or discount. This is calculated as the percentage difference between the mark price (the current trading price of the perpetual contract) and the index price (the spot price of the underlying asset aggregated from major exchanges).

• Sub-step 1: Fetch the current mark price from the perpetual contract's order book, typically the mid-price between the best bid and ask.
• Sub-step 2: Query the oracle for the current index price. For example, an ETH/USD perp might use an index composed of Coinbase, Binance, and Kraken spot prices.
• Sub-step 3: Apply the premium formula: Premium = ((Mark Price - Index Price) / Index Price) * 100%. A positive result indicates the perpetual is trading at a premium.

javascriptCopy
// Example premium calculation
const markPrice = 3050.50; // ETH Perp price
const indexPrice = 3000.00; // Spot index price
const premium = ((markPrice - indexPrice) / indexPrice) * 100;
console.log(`Premium: ${premium.toFixed(4)}%`); // Output: Premium: 1.6833%

Tip: The premium is a key signal. A sustained high premium suggests strong bullish sentiment in the derivatives market relative to spot, which will trigger payments from longs to shorts.

Detailed Instructions

The raw premium is fed into the protocol's funding rate formula. This formula typically includes a clamping mechanism and a rate cap to prevent excessive payments. The most common form is: Funding Rate = Premium / Funding Interval + Interest Rate Differential.

• Sub-step 1: Determine the funding interval. Most exchanges calculate and exchange funding every 8 hours, so the interval is 3 (times per day).
• Sub-step 2: Apply the clamping factor. Protocols often use a clamp coefficient (e.g., 0.05% or 5 basis points) to smooth volatility. The effective premium is max(min(Premium, Clamp), -Clamp).
• Sub-step 3: Add the interest rate component. This is a small fixed rate (often zero) representing the cost of capital difference between the two currencies.

pythonCopy
# Example funding rate calculation
premium = 0.016833  # 1.6833% from previous step
clamp = 0.0005      # 0.05% clamp
funding_interval = 3 # 8-hour intervals per day
interest_rate = 0.0001 # 0.01%

clamped_premium = max(min(premium, clamp), -clamp)
funding_rate = (clamped_premium / funding_interval) + interest_rate
print(f"Funding Rate: {funding_rate:.6f}") # Output: Funding Rate: 0.001767

Tip: The clamp is critical for system stability. It prevents funding rates from spiraling during extreme market volatility or oracle manipulation attempts.

Detailed Instructions

The sign of the funding rate dictates the cash flow direction. A positive funding rate means long positions pay shorts. A negative rate means shorts pay longs. The payment magnitude is the rate multiplied by the position size.

• Sub-step 1: Check the rate sign. Using the previous example, a rate of 0.001767 (0.1767%) is positive.
• Sub-step 2: Calculate the payment per contract. For a trader with a 1 ETH long position, the payment is Position Size * Funding Rate. At a mark price of $3050.50, the notional is $3050.50.
• Sub-step 3: Apply the payment. The long trader's account is debited 1 ETH * 0.001767 = 0.001767 ETH. This value is distributed proportionally to all short traders.

solidityCopy
// Simplified Solidity logic for payment direction
function getPaymentAmount(int256 fundingRate, uint256 positionSize) internal pure returns (int256 payment) {
    // fundingRate can be positive or negative
    payment = (fundingRate * int256(positionSize)) / 1e18; // Assuming 18 decimals for rate
    // If payment > 0, longs pay. If payment < 0, shorts pay.
}

Tip: The payment is applied directly to the position's collateral balance. A long trader paying funding will see their USDC or quote currency balance decrease, effectively incrementally closing their position unless more collateral is added.

Detailed Instructions

At predetermined funding timestamps (e.g., 00:00, 08:00, 16:00 UTC), the protocol's smart contract executes a state update to transfer the funding payments. This is a net settlement across all open positions.

• Sub-step 1: Snapshot open positions. The contract records all active long and short positions and their sizes at the funding time.
• Sub-step 2: Aggregate payments. It calculates the total quote currency (e.g., USDC) to be transferred from longs to shorts (or vice-versa) based on the finalized rate.
• Sub-step 3: Update account balances. The contract deducts payments from the margin balances of the paying side and credits the receiving side. No actual token transfer occurs; it's an internal ledger update.

javascriptCopy
// Pseudocode for funding settlement
async function settleFunding(rate) {
    const allLongs = await getOpenLongPositions();
    const allShorts = await getOpenShortPositions();
    
    let totalPaymentFromLongs = 0;
    for (let position of allLongs) {
        let payment = position.size * rate;
        totalPaymentFromLongs += payment;
        position.collateralBalance -= payment; // Deduct from long
    }
    // Distribute totalPaymentFromLongs proportionally to shorts
    distributeToShorts(totalPaymentFromLongs, allShorts);
}

Tip: This process is gas-efficient as it updates internal balances in a single transaction. Traders must maintain sufficient collateral to cover funding payments to avoid liquidation.

Detailed Instructions

The funding payment is a mechanism for convergence. By financially incentivizing one side of the market, it encourages trading activity that pushes the perpetual's price toward the spot index.

• Sub-step 1: Assess the incentive. A positive funding rate (longs pay) makes holding long positions more expensive. Rational traders may reduce long exposure or open shorts to collect payments.
• Sub-step 2: Observe market reaction. Increased selling pressure from longs closing or new shorts opening should cause the mark price to decrease toward the index price.
• Sub-step 3: Monitor the feedback loop. As the premium narrows, the next funding rate calculation will yield a smaller value, reducing the incentive. This creates a negative feedback loop that stabilizes the price peg.

Consider a scenario where ETH spot is $3000 but the perp trades at $3100. The 3.33% premium causes longs to pay ~1.11% every 8 hours. This cost may trigger:

1. Longs taking profits by selling their contracts.
2. Arbitrageurs selling the perp and buying spot ETH.
3. New traders opening shorts to earn the funding fee. All three actions increase sell-side pressure on the perp, pushing its price down toward $3000.

Tip: The efficiency of this mechanism depends on liquid markets and rational actors. In illiquid conditions, premiums/discounts can persist despite high funding rates.