Detailed Instructions

Before opening a position, you must provide collateral to back your trade. This is typically a stablecoin like USDC or a blue-chip asset like WETH. First, ensure your wallet holds sufficient funds. Then, you must approve the protocol's smart contract to spend the specific token you intend to deposit. This is a standard ERC-20 approve transaction, granting an allowance. The required allowance is the amount you plan to deposit plus a buffer for potential fees. Failing to approve or approving an insufficient amount will cause the subsequent deposit transaction to revert.

• Sub-step 1: Transfer the desired collateral token (e.g., 1000 USDC) to your Web3 wallet.
• Sub-step 2: Call the approve function on the token contract, specifying the perpetual protocol's vault address as the spender.
• Sub-step 3: Set the allowance to a value like type(uint256).max for unlimited approval, or a specific deposit amount.

solidityCopy
// Example: Approving a vault contract to spend USDC
IERC20(usdcAddress).approve(vaultAddress, type(uint256).max);

Tip: Use a block explorer to verify the approval transaction succeeded and the allowance mapping is correctly updated.

Detailed Instructions

With collateral approved, you can now open a position. This involves calling the protocol's openPosition or increasePosition function. You must specify key parameters: the market index (e.g., ETH-USD), the side (long or short), the collateral amount to commit, and the desired leverage. The protocol calculates the notional value of your position as collateral * leverage. A critical parameter is the acceptable price impact, often set via a slippage tolerance (e.g., 0.5%). This protects you from excessive fees if the oracle price moves before your transaction is mined.

• Sub-step 1: Determine the market ID (e.g., 1 for ETH/USD) and the position side (true for long, false for short).
• Sub-step 2: Decide on collateral amount (e.g., 1000 USDC) and leverage (e.g., 5x).
• Sub-step 3: Set a maximum acceptable slippage, often as a basis points value like 50 for 0.5%.

javascriptCopy
// Pseudo-call to a typical openPosition function
await perpsContract.openPosition(
  marketIndex, // e.g., 1
  isLong,      // boolean
  collateralDelta, // e.g., ethers.parseUnits("1000", 6) for USDC
  sizeDelta,   // calculated as collateralDelta * leverage
  acceptablePrice // current index price * (1 ± slippage)
);

Tip: Higher leverage increases both potential profit and liquidation risk. Monitor the initial margin requirement for your chosen market.

Detailed Instructions

After opening, active management is required. The health ratio (or margin ratio) is the primary metric for solvency. It is calculated as (collateral value) / (maintenance margin requirement). If this ratio falls below 1.0, your position becomes eligible for liquidation. You must also account for funding rates. Perpetual contracts use periodic payments between longs and shorts to peg the perpetual price to the spot index. Funding is typically paid or received every 1-8 hours. A positive rate means longs pay shorts; a negative rate means shorts pay longs. These payments directly adjust your collateral balance.

• Sub-step 1: Query your position's collateral, size, and entryPrice from the protocol's user position mapping.
• Sub-step 2: Calculate the current unrealized P&L and the maintenance margin based on the market's parameters.
• Sub-step 3: Check the next funding timestamp and the predicted funding rate for your market side.

solidityCopy
// Example struct for a user position (conceptual)
struct Position {
    uint256 size;
    uint256 collateral;
    int256 entryFundingRate;
}
// Health check logic
bool isHealthy = (collateral + unrealizedPnl) >= maintenanceMargin;

Tip: Automate monitoring with off-chain bots or set up alerts for when your health ratio nears the liquidation threshold.

Detailed Instructions

You can adjust an open position without closing it. Adding collateral increases your health ratio, making the position safer from liquidation. This is done via a depositCollateral function call. Removing collateral (withdrawing) decreases the health ratio and increases risk, often restricted unless the position remains above the initial margin requirement. You can also adjust leverage by increasing or decreasing the position size. Increasing size adds to your market exposure, while decreasing it (partial close) reduces exposure and can realize some profit or loss.

• Sub-step 1: To add collateral, call addCollateral with the market ID and the additional token amount.
• Sub-step 2: To remove collateral, call removeCollateral, ensuring your remaining margin stays above the required threshold.
• Sub-step 3: To adjust leverage, call increasePosition or decreasePosition with a new sizeDelta value.

solidityCopy
// Example interface for position management
interface IPerpsVault {
    function addCollateral(uint256 marketId, uint256 amount) external;
    function removeCollateral(uint256 marketId, uint256 amount) external;
    function decreasePosition(
        uint256 marketId,
        uint256 sizeDelta,
        address receiver
    ) external;
}

Tip: Decreasing a position size often provides better execution than closing fully and reopening, as it may incur lower fees.

Detailed Instructions

Closing a position settles all unrealized P&L and returns the remaining collateral to your wallet. You initiate a market close by calling closePosition or setting sizeDelta to your full position size in a decreasePosition call. The protocol executes an offsetting trade against the liquidity pool or order book. The resulting realized P&L is calculated as (exitPrice - entryPrice) * size * sideMultiplier. This amount, positive or negative, is added to your collateral balance. After closing, you must withdraw your settled collateral via a separate transaction if it's not automatically returned.

• Sub-step 1: Query your open position to get the exact positionSize.
• Sub-step 2: Execute a close transaction, specifying the full size and an acceptable exit price to prevent front-running.
• Sub-step 3: Verify the transaction receipt and check your wallet's balance of the collateral token.
• Sub-step 4: If necessary, call the vault's withdraw function to transfer funds out of the protocol.

javascriptCopy
// Example close and withdraw flow
const position = await perpsContract.getPosition(userAddress, marketId);
await perpsContract.closePosition(marketId, position.size, acceptablePrice);
await vaultContract.withdraw(usdcAddress, withdrawAmount);

Tip: Account for trading fees and funding payments in your final P&L calculation. The net profit is the change in your collateral balance from start to finish.

Detailed Instructions

The premium index is the core input for funding calculations. It measures the deviation between the perpetual futures market price and the real-world spot price.

• Sub-step 1: Fetch the mark price. This is typically a time-weighted average price (TWAP) from major spot exchanges to prevent manipulation. For example, a protocol might use a 1-hour TWAP from Binance, Coinbase, and Kraken.
• Sub-step 2: Fetch the index price. This is the current spot price of the underlying asset, often aggregated from multiple centralized and decentralized exchanges.
• Sub-step 3: Compute the premium. The formula is: Premium Index = (Mark Price - Index Price) / Index Price. A positive value indicates the perpetual is trading at a premium.

solidityCopy
// Simplified premium calculation logic
int256 premium = (markPrice - indexPrice) * 1e18 / indexPrice;

Tip: The premium is usually calculated and updated at fixed intervals (e.g., every minute) to ensure the funding rate reflects near-real-time market conditions.

Detailed Instructions

The raw premium is too volatile for direct use. Protocols apply a clamp and averaging mechanism to produce a stable funding rate.

• Sub-step 1: Apply a clamp (cap). The premium is typically constrained within a bound (e.g., ±0.05%) to prevent extreme payments. If the calculated premium is 0.08%, it is clamped to 0.05%.
• Sub-step 2: Apply an 8-hour moving average. The clamped premium is averaged over the last 8 hours to smooth out short-term spikes. The formula is: Funding Rate = (Average of Clamped Premium over 8 hours) + Interest Rate Differential.
• Sub-step 3: Add the interest rate component. A small fixed rate (e.g., 0.01%) may be added, representing the cost of capital difference between the two assets in the pair (like ETH and USD).

javascriptCopy
// Pseudo-code for funding rate calculation
const clampedPremium = Math.max(Math.min(rawPremium, CAP), -CAP);
const eightHourMA = calculateMovingAverage(clampedPremium, 8);
const fundingRate = eightHourMA + interestRate;

Tip: The interest rate component is often negligible compared to the premium-driven component but ensures funding flows from longs to shorts in a neutral market.

Detailed Instructions

Funding payments are settled periodically, typically every 8 hours (e.g., at 00:00, 08:00, 16:00 UTC). The direction of payment depends on the sign of the funding rate.

• Sub-step 1: Identify payer and receiver. A positive funding rate means longs pay shorts. A negative funding rate means shorts pay longs. The payment is proportional to position size and the rate.
• Sub-step 2: Calculate payment per position. The formula is: Payment = Position Size * Funding Rate. For a $10,000 long position with a +0.05% rate, the long pays $5 to the short.
• Sub-step 3: Settle via the vault. Payments are deducted from margin balances and distributed directly to counterparties via the protocol's settlement vault. No actual trading occurs; it's a balance transfer.

solidityCopy
// Core settlement logic in a vault contract
function _settleFunding(address trader, int256 fundingRate) internal {
    int256 payment = positionSize * fundingRate / 1e18;
    if (payment > 0) {
        // Long pays short
        marginBalance[trader] -= uint256(payment);
        vaultBalance += uint256(payment);
    } else {
        // Short pays long
        marginBalance[trader] += uint256(-payment);
        vaultBalance -= uint256(-payment);
    }
}

Tip: Payments are often made in the settlement asset (e.g., USDC), not the underlying, to avoid volatility during the payment process.

Detailed Instructions

The funding rate creates a counter-cyclical economic pressure that acts as a convergence mechanism.

• Sub-step 1: Assess the incentive. When the perpetual trades at a premium (mark price > index), the funding rate is positive. Longs pay shorts, incentivizing traders to open short positions or close longs, which sells pressure pushes the mark price down.
• Sub-step 2: Assess the reverse incentive. When the perpetual trades at a discount (mark price < index), the funding rate is negative. Shorts pay longs, incentivizing traders to open long positions or close shorts, buying pressure pushes the mark price up.
• Sub-step 3: Observe equilibrium. In a perfectly balanced market with no premium, the funding rate approaches zero, removing the incentive for directional pressure. The mechanism does not guarantee peg but creates a strong mean-reverting force.

Tip: During periods of extreme sentiment (e.g., a bull run), sustained high positive funding rates can become a significant cost for leveraged long positions, acting as a built-in brake on over-leverage.

Detailed Instructions

Different protocols (e.g., dYdX, GMX, Perpetual Protocol) implement unique parameters. Understanding these is crucial for risk management.

• Sub-step 1: Check the funding interval. While 8 hours is common, some protocols use 1 hour (e.g., earlier dYdX) or even continuous funding. Shorter intervals reduce payment size but increase frequency.
• Sub-step 2: Review the premium clamp. The maximum absolute funding rate is capped (e.g., ±0.075%). In a volatile squeeze, this cap can break the peg, as the incentive may be insufficient to correct large premiums.
• Sub-step 3: Understand funding rate risk. The primary risk is funding rate volatility. A position can be profitable on price movement but lose value due to unfavorable, sustained funding payments. Always model worst-case funding scenarios.

javascriptCopy
// Example: Fetching current parameters from a typical perpetual contract
const fundingParams = await perpContract.getFundingParameters();
// Returns: { fundingInterval: 28800, // 8 hours in seconds
//            maxFundingRate: 750000000000000, // 0.075% in 1e18 precision
//            twapPeriod: 3600 } // 1-hour TWAP for mark price

Tip: During high volatility or low liquidity, the index price oracle can lag, causing temporary but impactful distortions in the funding rate calculation.