UPDATES

Voltr has adaptors. They work. You can deposit, withdraw, swap through Jupiter — the basics are covered. So why did we spend days writing 346KB of Rust from scratch?

Because the basics aren't enough for what we're doing.

Our vault runs a delta-neutral hJLP strategy. That means JLP sits as collateral on Drift, earning ~35% APY from trading fees, while short perps (SOL/BTC/ETH) hedge away the crypto exposure. The problem: rebalancing this position requires atomically adjusting perp positions alongside collateral changes. You can't do that with a generic swap adaptor. You need a program that understands Drift's cross-margin engine.

The existing approach was an off-chain keeper — a TypeScript bot that reads state, computes targets, sends transactions. It works, but it's a trust assumption. The keeper has a wallet. The wallet has authority. If the keeper misbehaves or gets compromised, the vault is exposed.

The on-chain adaptor eliminates this. Six instructions:

initialize, deposit, withdraw, rebalance, crank_hedge, emergency_exit. The rebalance instruction is the key — it takes a target allocation, computes the delta from current positions, and atomically adjusts JLP collateral and perp hedges in a single transaction through Drift's CPI. No off-chain trust required.

The 2.1 SOL deployment cost is actually a feature, not a bug. It means the program is real and permanent — deployed on-chain, verified, immutable unless you explicitly upgrade. That's the whole point. The code is the authority, not a hot wallet.

Ships April 2026. The adaptor compiles clean today. Deployment is just a matter of having 2.5 SOL in the right wallet.

Let's be clear about something: this is not prompt engineering. There are no LLMs in the trading loop. What we built is a proper ML pipeline — trained on real market data, validated with walk-forward testing, exported to ONNX for sub-10ms inference. Here's what's under the hood.

Component 1: HMM Regime Detection. A 3-state Hidden Markov Model classifies the current market as CALM, TRENDING, or VOLATILE. This is the single biggest contributor to performance. Why? Because it drives adaptive leverage. In calm markets, we run 3x leverage on the hJLP position. Trending markets drop to 2x. Volatile markets pull back to 1.5x. A fixed-leverage strategy gets destroyed in drawdowns. Ours ducks.

Component 2: LightGBM Funding Prediction. A gradient-boosted model forecasts SOL-PERP funding rates 24 hours ahead. Funding rates are the lifeblood of the basis trade component — when perps trade at a premium, shorts collect funding. The model helps us time entries and size positions. It's not magic, but it's measurably better than static assumptions.

Component 3: No-Trade Zones. This is the unsung hero. Regime-dependent rebalance bands that prevent the keeper from trading when the expected gain doesn't justify the cost. Calm market? Don't rebalance unless allocation drifts more than 8%. Volatile? Widen to 15%. Result: 63% fewer transactions, $435 saved in costs, and almost no impact on returns.

We ran a proper ablation study. Variant A (static 3x leverage, no ML): 42.9% APY, 3.06 Sharpe. Variant B (add regime detection + adaptive leverage): 54.6% APY, 4.32 Sharpe. That's an 11.7% absolute improvement in APY from one component. The regime detector earned its keep.

For production, we're deploying Variant D — the full system with no-trade zones. It trades off ~2.5% APY versus Variant B but cuts transaction count by 63%. In live markets with real slippage and gas costs, fewer trades wins. The backtest says 52.1% APY. Now we find out if the market agrees.

22,731 hours of training data. 5,921 hours of walk-forward validation. 32 retraining folds. Models exported to ONNX and running in the keeper with sub-10ms latency. This is the kind of ML that actually makes money — not because it's clever, but because it's disciplined.

The vault is live on mainnet. Not "coming soon." Not "testnet." Live, with real capital, processing real transactions.

Here's what happened in the first 8 hours:

The keeper bot came online and immediately started running its loop — read vault state, check regime, compute target allocation, evaluate whether to rebalance, execute if needed. 100+ cycles with no crashes, no stuck transactions, no panics. The circuit breakers are armed. The position limits are enforced. The monitoring dashboard is streaming events.

The custom Rust adaptor compiles. All 6 instructions pass local testing. Deployment is pending — we need ~2.5 SOL for the program deployment, which is non-trivial when you're building a hackathon project. That's next.

What we know from backtesting: 54.6% APY over 246 days. 4.32 Sharpe ratio. Max drawdown of -7.58%. But backtests are backtests. Every quant knows the gap between simulation and reality. Slippage is real. Gas costs are real. Oracle delays are real. Funding rates don't stay in neat distributions.

The next 10 days are what matter. Deploy the on-chain adaptor. Accumulate live APY data. Tune the keeper against actual market conditions. Submit for the hackathon with real numbers — not promises, not projections, but actual on-chain performance.

This is what building in public looks like. No vaporware. Ship first, talk later.