DeltaGrid

01 — AbstractProtocol Overview

Theoretical foundations and positioning of the strategy within the DeFi ecosystem.

DeltaGrid is a multi-chain automated liquidity provision system operating at the intersection of three quantitative trading disciplines: directional exposure neutralization (delta hedging), volatility capture (gamma scalping), and mechanical execution at predefined price levels (grid trading).

The core innovation lies in the combination of two operational ranges adaptive to realized volatility — a narrow range (N × realized vol) for high-frequency micro-movement capture, and a wide range (M × realized vol, M > N) for protection against directional moves and capture of larger swings. The ranges self-calibrate to the market regime: tightening in sideways to maximize fee capture and widening in high volatility to protect against impermanent loss.

The technology stack uses concentrated liquidity protocols (CLMM) and decentralized perpetuals across multiple networks. On Solana: ORCA Whirlpools + Drift Protocol (~400ms latency, gas < $0.01). On BSC: PancakeSwap v3 + ApolloX (~3s latency, gas ~$0.03-0.10). The architecture is chain-agnostic — the core logic works on any network with CLMM + perps.

02 — Core StrategyOperational Mechanics

How the three components work together to generate operational results across multiple networks.

Fundamental Principle

The strategy operates under the principle that volatility is the true asset. Instead of betting on price direction, DeltaGrid monetizes the movement itself. Each oscillation within the narrow range generates LP fees; each larger movement captured by the wide range generates grid spread; and the short position in perpetuals via Drift ensures that none of these results are consumed by unintended directional exposure.

03 — ArchitectureTechnology Stack

On-chain and off-chain components of the multi-chain system.

03.B — Supported NetworksMulti-Chain Infrastructure

The DeltaGrid strategy is chain-agnostic: any network with CLMM + perps supports the core logic.

04 — Dual Range GridOperational Levels

Visualization of the 5 price levels and capital allocation per level.

Grid Levels — SOL/USDC (Illustrative Example | Vol window: proprietary)

04.1 — Tick MathematicsRange Calculation & Rebalancing

CLMM constraints, tick/price conversion, and repositioning mechanics.

Price Model by Ticks

ORCA Whirlpools (like Uniswap V3) does not operate with continuous prices. The price space is discretized into ticks, where each tick represents a 0.01% variation (factor of 1.0001). The price at any tick is defined by the formula:

// Price from a tick index
price = 1.0001 ^ tick_index

// Tick index from a price
tick_index = log(price) / log(1.0001)

// Example: SOL = $180.00
tick = log(180) / log(1.0001) = 51,917.4

// Price variation per tick spacing (64 ticks)
Δ_price = 1.0001 ^ 64 - 1 ≈ 0.6417%

// SOL exposure in an LP position
SOL_amount = liquidity × (1/√price_current - 1/√price_upper)

Tick Spacing Constraint

In the SOL/USDC pool with 0.30% fee tier, the tick spacing is 64. LP positions can only be opened at ticks that are exact multiples of 64. This means the smallest possible range increment is ~0.6417% (equivalent to 1 tick spacing). It is not possible to define arbitrary ranges — every range must be an integer multiple of 0.6417%.

Available Ranges

Step-by-Step Calculation (Practical Example)

With SOL at $180.00, the keeper calculates the narrow range as follows:

// 1. Convert current price to tick
current_tick = log(price) / log(1.0001)

// 2. Round to nearest tick_spacing multiple
base_tick = floor(current_tick / tick_spacing) × tick_spacing

// 3-5. Proprietary expansion
// The number of tick spacings per side is determined by the
// proprietary vol-adaptive model (multipliers × realized vol).
// The final bounds and rounding are proprietary.

Rebalancing Mechanics

Rebalancing does not use percentages — it compares tick indexes directly. When the pool's current tick moves N tick spacings away from the position's base_tick, the keeper triggers repositioning. This is faster (integer comparison) and eliminates floating point errors.

Rebalancing Flow — Narrow Range

EMA Smoothing

To avoid unnecessary rebalances caused by wicks or momentary manipulation, the keeper uses a smoothed price (short-term EMA, proprietary period) as a confirmation filter. The tick spacing threshold is measured against the current center_tick, but rebalancing only executes if the EMA also confirms the deviation (deviation confirmation by the EMA (proprietary threshold)). This prevents "rebalance ping-pong" in choppy markets.

SOL Exposure Calculation for Hedge

The amount of SOL in a CLMM position varies as the price moves within the range. At the lower bound, the position is 100% SOL. At the upper bound, 100% USDC. The keeper calculates the total SOL exposure from both positions and adjusts the Drift short to maintain delta ≈ 0.

04.2 — Volatility-Adaptive RangesDynamic Ranges by Realized Volatility

Range self-calibration based on realized volatility with proprietary multipliers and safety bounds.

The Problem with Fixed Ranges

Static ranges fail at both extremes of the volatility spectrum. In low-vol sideways, a fixed range spreads liquidity too thin — fee capture is weak. In high vol, the same fixed range is too narrow — the price exits the range constantly, forcing excessive rebalances that consume gas and suffer slippage.

Solution: Multiplier on Realized Volatility

DeltaGrid calculates realized volatility (EWMA of hourly logarithmic returns, proprietary window) and applies two fixed multipliers to define ranges dynamically:

// Adaptive range calculation pipeline:
//
// 1. Calculate realized volatility via EWMA
//    - Window and decay factor (λ) are proprietary
//    - Hourly logarithmic returns as input
//
// 2. Apply proprietary multipliers
//    - Narrow range = N × σ (N proprietary)
//    - Wide range = M × σ (M proprietary, M > N)
//
// 3. Apply safety bounds (proprietary floor and ceiling)
//    - Prevents excessive concentration (floor)
//    - Prevents excessive dispersion (ceiling)
//
// 4. Convert percentages to tick spacings
//    - Round up to pool tick spacing
//
// 5. Build CLMM positions
//    - Center tick + symmetric expansion

Behavior by Market Regime

Safety Bounds (Floor & Ceiling)

Adaptive ranges are limited by absolute bounds to prevent harmful extremes:

EWMA vs Simple Standard Deviation

DeltaGrid uses EWMA (Exponentially Weighted Moving Average) with a proprietary decay factor instead of simple standard deviation. EWMA gives more weight to recent data without abandoning the window context, reacting faster to regime changes. The decay factor and effective half-life are calibrated via extensive backtesting — recent data receives proportionally greater weight.

Early Warning: Short-Term Vol

To solve the lag problem (main window vol still low when a crash begins), the keeper additionally monitors short-term vol (proprietary window). If the short-term vol exceeds a proprietary threshold of the main vol, the ranges expand preventively. This works as an early warning — ranges are already open before the main window updates.

05 — ORCA WhirlpoolsConcentrated Liquidity

Concentrated liquidity provision to maximize fee capture.

ORCA Whirlpools is the concentrated liquidity (CLMM) implementation on Solana. Similar to Uniswap V3, it allows liquidity providers to define specific price ranges for their positions, concentrating capital where it is most efficient.

Position Configuration

DeltaGrid maintains two simultaneous LP positions on the SOL/USDC Whirlpool, each with a distinct range. The narrow range position is optimized for fee capture on daily oscillations (gamma scalp), while the wide range position serves as a safety net and captures larger swings.

05.B — PancakeSwap v3Concentrated Liquidity (BSC)

BSC implementation of concentrated liquidity provision.

PancakeSwap v3 is the concentrated liquidity (CLMM) implementation on BNB Smart Chain. It uses the same Uniswap V3 and ORCA Whirlpools math. DeltaGrid maintains two simultaneous LP positions on the BNB/USDT pool, following the same dual range logic.

Technical Differences vs Solana

06 — Drift ProtocolDelta Hedge Engine

Directional exposure neutralization via decentralized perpetuals.

Drift Protocol is the leading decentralized perpetuals exchange on Solana. In DeltaGrid, Drift serves as the hedge engine — all SOL exposure generated by the LP positions on ORCA is counterbalanced by a proportional SHORT position on Drift perpetuals.

Hedge Mechanics

When the keeper contract allocates capital to the SOL/USDC Whirlpool, the SOL portion creates implicit long exposure. To neutralize it, the contract opens an equivalent SHORT position on Drift SOL-PERP. The result is a position with delta close to zero — capturing fees and spread, with no directional exposure.

Funding Rate as Additional Result

Perpetual contracts have a funding rate mechanism that transfers capital between longs and shorts every 1-8 hours. Historically, SOL funding rates are positive on average (longs pay shorts), meaning the DeltaGrid short position collects funding as a market fee paid by perpetual traders.

06.B — ApolloX (APX)Delta Hedge Engine (BSC)

Directional exposure neutralization via perpetuals on BNB Smart Chain.

ApolloX (APX) is a decentralized perpetuals exchange on BSC. In DeltaGrid, ApolloX serves as the hedge engine on BSC — all BNB exposure generated by the LP positions on PancakeSwap v3 is counterbalanced by a proportional SHORT position on ApolloX perpetuals.

Comparison: Drift vs ApolloX

07 — Keeper ContractAutomation and Execution

Off-chain component responsible for monitoring and executing technical operations.

// The Keeper Contract operates via 6 independent modules:
//
// Module 1: VOLATILITY CALCULATOR
//   → Calculates realized vol via EWMA with proprietary window and λ
//   → Monitors short-term early warning
//   → Determines effective vol for range calculation
//
// Module 2: RANGE OPTIMIZER
//   → Applies proprietary multipliers (N × σ, M × σ)
//   → Applies proprietary floor/ceiling bounds
//   → Converts to integer tick spacings
//
// Module 3: POSITION MANAGER
//   → Detects price deviation vs center tick
//   → Uses confirmation EMA to avoid false rebalances
//   → Executes remove LP → swap → new position atomically
//
// Module 4: HEDGE SYNCHRONIZER
//   → Calculates total exposure (narrow + wide)
//   → Adjusts short position on perpetuals proportionally
//   → Maintains delta ≈ 0 in real time
//
// Module 5: FEE COMPOUNDER
//   → Collects accumulated LP fees and perp funding
//   → Reallocates to positions when threshold is reached
//
// Module 6: HEALTH MONITOR
//   → Checks margin health on perpetuals
//   → Monitors capital reserve
//   → Automated alerts for incidents
//   → Emergency exit if drawdown exceeds threshold

08 — Risk ManagementRisk Framework

Identification, quantification, and mitigation of operational risks.

09 — Financial ModelingOperational Estimates

Conservative, moderate, and optimistic estimates based on historical data.

10 — Market ScenariosPerformance by Regime

How the strategy behaves under different market conditions.

11 — Smart Contract SpecsTechnical Specification

Definition of interfaces, permissions, and on-chain program parameters.

// DeltaGrid Vault — Solana Program (Anchor Framework)
// Public interface only. VaultConfig contains proprietary
// parameters: multipliers, windows, thresholds,
// allocations, and bounds. Defined by admin.

pub enum Instruction {
    Initialize(VaultConfig),  // Admin — proprietary params
    Allocate(u64),           // User allocates USDC
    Deallocate(u64),         // User removes USDC
    RepositionNarrow,        // Keeper: narrow range
    RepositionWide,          // Keeper: wide range
    AdjustHedge(i64),        // Keeper: adjust short
    Compound,                // Keeper: compound fees
    EmergencyExit,           // Emergency
    UpdateConfig(VaultConfig),// Admin: update params
}

BSC Implementation (Solidity)

On BSC, the vault is implemented as a Solidity smart contract. The core logic is identical to the Solana version, adapted for the EVM paradigm.

// DeltaGrid Vault — BSC (Solidity)
// Proprietary VaultConfig (same categories as Solana).

function allocate(uint256 amount) external;     // User allocates USDT
function deallocate(uint256 amount) external;  // User removes USDT
function repositionNarrow() external;           // Keeper only
function repositionWide() external;             // Keeper only
function adjustHedge(int256 delta) external;    // Keeper only
function compound() external;                    // Keeper only
function emergencyExit() external;               // Emergency

12 — OperationsOperational Infrastructure

Infrastructure requirements and protocol monitoring.

13 — RoadmapDevelopment Plan

Implementation, testing, and launch phases for DeltaGrid.

— How to VerifyOn-Chain Verification

DeltaGrid activity is independently verifiable by any observer.