Vantide Protocol
Documentation

Quick Start Guide

Vantide runs entirely on BNB Smart Chain (Chain ID 56). You interact with the protocol through a standard EVM-compatible wallet. No account signup, no KYC — just a wallet and collateral.

Step 1 — Connect Your Wallet

Vantide supports MetaMask, WalletConnect, and any EVM-compatible wallet. The frontend is built on React/Next.js with ethers.js for all wallet interactions.

Step 2 — Open a Perpetual Position

Vantide perpetuals are settled entirely on BNB Smart Chain. The vAMM continuously provides liquidity backed by the unified vault, so you can enter and exit positions without needing a counterparty.

Step 3 — Provide Liquidity to the Vault

The Vantide vault is a unified single-pool backing all perpetual markets simultaneously. By depositing USDT into the vault, you become a counter-party to all open positions and earn trading fees, funding payments, and liquidation premiums.

Perpetual Engine

Vantide uses a hybrid execution model combining a virtual AMM (vAMM) with optional order book settlement. The vAMM provides always-on liquidity for market orders while larger or more complex orders can be routed through the off-chain matching engine with on-chain settlement.

Virtual AMM (vAMM)

Inspired by the architecture pioneered by Perpetual Protocol, Vantide's vAMM does not hold real assets in the AMM pool — it simulates price discovery using a virtual constant-product formula k = x · y. The vault provides the actual collateral backing.

The key advantage: you always have a counterparty. No order book depth required for entry or exit. The vAMM state is updated atomically with each trade on-chain.

// Virtual AMM price impact calculation
// k = invariant constant (set by protocol governance)
// baseReserve = virtual BTC/ETH/BNB reserve
// quoteReserve = virtual USDT reserve

function getOutputAmount(
    uint256 inputAmount,
    bool isLong
) external view returns (uint256 outputAmount) {
    uint256 k = baseReserve * quoteReserve;

    if (isLong) {
        // Long: add USDT to quote, reduce base
        uint256 newQuote = quoteReserve + inputAmount;
        uint256 newBase  = k / newQuote;
        outputAmount = baseReserve - newBase;
    } else {
        // Short: add base, reduce quote
        uint256 newBase  = baseReserve + inputAmount;
        uint256 newQuote = k / newBase;
        outputAmount = quoteReserve - newQuote;
    }
}

Mark Price vs Index Price

Two prices govern all operations on Vantide:

Mark Price — the vAMM's current implied price. Used to calculate unrealized PnL and trigger liquidations. Calculated as a weighted average of the vAMM price and the Chainlink index price to prevent manipulation.

Index Price — sourced directly from Chainlink's decentralized oracle network on BNB Chain. Represents the true spot market price. Used for funding rate calculations and as a manipulation-resistant reference.

The protocol enforces a deviation limit: if mark price deviates more than a configured threshold from the index price, certain operations are restricted until prices reconverge.

Unified Vault

The Vantide vault is a single pooled capital system that backs all perpetual markets simultaneously. This is architecturally distinct from systems with per-market liquidity pools, where capital is fragmented and markets can suffer independent liquidity crises.

The vault operates as the counterparty to all trades. When traders profit, the vault pays out. When traders lose, the vault collects. Fees, funding payments, and liquidation premiums are all deposited into the vault and distributed proportionally to LP token holders.

VLP Token Mechanics

When you deposit USDT into the vault, you receive VLP tokens at the current vault price:

// VLP price = Total Vault Assets / Total VLP Supply
// Total Vault Assets = deposited USDT + unrealized PnL + fees accrued

VLP_price = (vaultUSDT + accruedFees + pendingLiquidationRevenue
             - unrealizedTraderPnL) / totalVLPSupply

// Depositing: VLP minted = USDT deposited / VLP_price
// Withdrawing: USDT returned = VLP burned × VLP_price

Margin & Leverage

Vantide supports both isolated margin and cross margin modes, managed by the MarginEngine.sol contract.

Isolated Margin

In isolated margin mode, each position has its own dedicated collateral pool. The maximum loss for any single trade is capped at the collateral assigned to that specific position. This is the safer default for newer traders as one bad position cannot affect others.

Cross Margin

In cross margin mode, your entire account balance serves as collateral for all open positions collectively. Profitable positions offset losing ones. This allows for higher total leverage but also means one large loss can trigger liquidation of all positions simultaneously.

// Maintenance Margin Ratio (MMR) = typically 2.5% (protocol param)
// Initial Margin = Position Size / Leverage
// Maintenance Margin = Position Size × MMR

// Liquidation price (Long):
liq_price_long = entry_price × (1 - (1/leverage) + MMR)

// Liquidation price (Short):
liq_price_short = entry_price × (1 + (1/leverage) - MMR)

// Example: BTC Long, $50,000 entry, 10x leverage, 2.5% MMR:
// liq_price = 50,000 × (1 - 0.1 + 0.025) = 50,000 × 0.925 = $46,250

Funding Rate Mechanism

The funding rate is a periodic payment exchanged between long and short position holders. Its purpose is to keep the perpetual contract's mark price anchored to the Chainlink index (spot) price, preventing sustained divergence.

// Funding Rate = Premium Index + Clamp(Interest Rate - Premium Index, -Cap, Cap)
// Premium Index  = (Mark Price - Index Price) / Index Price
// Interest Rate  = 0.01% per 8h (protocol default)
// Funding Cap    = ±0.75% per 8h interval

premium_index = (mark_price - index_price) / index_price

funding_rate = clamp(
    premium_index + interest_rate,
    -0.0075,  // -0.75% floor
     0.0075   // +0.75% ceiling
)

// Payment per position every 8 hours:
// Funding Payment = Position Size × Funding Rate
// Positive funding: longs pay shorts
// Negative funding: shorts pay longs

Funding payments are settled every 8 hours and deducted directly from position margin. If margin falls below maintenance margin as a result, partial or full liquidation may be triggered.

Liquidation Engine

When a position's margin falls below the maintenance margin threshold, the LiquidationEngine.sol contract allows liquidator bots to close the position and claim a liquidation fee.

The liquidation process:

Signal-Minimized Execution

Traditional DEXs broadcast trade intent to the public mempool before execution. This creates a window where MEV bots can front-run, sandwich, or copy your strategy before your transaction is included in a block.

Vantide's execution model is designed to close this window:

Contract Reference

All Vantide contracts are written in Solidity and deployed on BNB Smart Chain (Chain ID 56). Contract addresses will be published here at protocol launch following audit completion.

SDK / ethers.js Integration

Vantide does not publish a proprietary SDK. All contract interactions can be performed directly using ethers.js v6 or Web3.js with the published ABI files. The frontend itself uses ethers.js via Next.js.

Setup & connection

import { ethers } from 'ethers';

// BNB Smart Chain RPC
const BNB_RPC = 'https://bsc-dataseed.binance.org/';
const provider = new ethers.JsonRpcProvider(BNB_RPC);

// Connect wallet (MetaMask / WalletConnect)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();

// Instantiate PositionRouter contract
const positionRouter = new ethers.Contract(
    POSITION_ROUTER_ADDRESS,  // published at launch
    POSITION_ROUTER_ABI,
    signer
);

Opening a position

import { parseUnits } from 'ethers';

// Approve USDT for PositionRouter
const usdtContract = new ethers.Contract(USDT_ADDRESS, ERC20_ABI, signer);
await usdtContract.approve(
    POSITION_ROUTER_ADDRESS,
    parseUnits('1000', 18)  // approve 1000 USDT
);

// Open a long BTC-USDT position
const tx = await positionRouter.openPosition({
    market:     'BTC-USDT',         // market identifier
    isLong:     true,               // direction
    collateral: parseUnits('100', 18),  // 100 USDT collateral
    leverage:   10,                 // 10x leverage
    slippage:   50,                 // 0.5% max slippage (bps)
});

const receipt = await tx.wait();
console.log('Position opened:', receipt.hash);

Reading vault TVL

const vault = new ethers.Contract(VAULT_ADDRESS, VAULT_ABI, provider);

// Total USDT held in vault
const tvl = await vault.totalAssets();
console.log('TVL (USDT):', ethers.formatUnits(tvl, 18));

// Current VLP price
const vlpPrice = await vault.getVLPPrice();
console.log('VLP Price (USDT):', ethers.formatUnits(vlpPrice, 18));

// Your VLP balance
const vlpBalance = await vault.balanceOf(await signer.getAddress());
console.log('Your VLP:', ethers.formatUnits(vlpBalance, 18));

REST API Reference

The Vantide backend (Node.js/Golang) exposes a REST API for off-chain data aggregation — price feeds, position queries, and market data. All state-changing operations must go through on-chain contract calls.

Base URL: https://api.vantide.io/v1 — Live at protocol launch

Market Data

Position Queries

Vault Data

The Graph — GraphQL Subgraph

All on-chain events emitted by Vantide contracts are indexed by a custom subgraph deployed on The Graph. This enables rich historical queries and real-time subscriptions without running a full node.

Subgraph endpoint: https://api.thegraph.com/subgraphs/name/vantide/vantide-bnb — Live at launch

Example queries

{
  positions(
    first: 10,
    orderBy: timestamp,
    orderDirection: desc,
    where: { isOpen: true }
  ) {
    id
    trader
    market
    isLong
    collateral
    leverage
    entryPrice
    markPrice
    unrealizedPnl
    liquidationPrice
    openedAt
  }
}

{
  dailyStats(
    first: 7,
    orderBy: date,
    orderDirection: desc
  ) {
    date
    volumeUSD
    feesCollected
    uniqueTraders
    openInterest
    vaultTVL
    vlpPrice
  }
}

Fee Schedule

Vantide uses a simple, transparent fee model. All fees are taken in USDT from position collateral at the time of execution.

Supported Perpetual Markets

Vantide launches with three core perpetual markets, with additional markets governed by community proposals post-launch.

Network & RPC Configuration

Add BNB Smart Chain to your wallet using the parameters below.

Network Name:    BNB Smart Chain
RPC URL:         https://bsc-dataseed.binance.org/
Chain ID:        56
Currency Symbol: BNB
Block Explorer:  https://bscscan.com

// Alternative RPCs (fallbacks):
// https://bsc-dataseed1.defibit.io/
// https://bsc-dataseed1.ninicoin.io/
// wss://bsc-ws-node.nariox.org:443 (WebSocket)

// Collateral token:
USDT (BEP-20): 0x55d398326f99059fF775485246999027B3197955
               (Verify on BscScan before use)

Frequently Asked Questions

Further Reading