QuantumVault
Autonomous Perpetual Futures Trading Platform on Solana
Live at myquantumvault.com
QuantumVault enables users to deploy and manage autonomous perpetual futures trading bots on Solana. The platform automates trade execution via TradingView webhooks and AI agent signals, provides real-time position tracking, and integrates with Phantom Wallet for seamless Solana DeFi access.
The platform routes trades through a protocol-agnostic adapter layer, with Pacifica.fi as the primary execution venue and Drift Protocol registered as a backup adapter. New venues can be added without touching the core trading engine.
This is not a demo or proof of concept — QuantumVault is live on Solana mainnet processing real trades with real capital.
What Makes It Novel
- Protocol-Agnostic Adapter Architecture — A ports-and-adapters (hexagonal) layer abstracts every exchange behind a single
ProtocolAdapter interface. Adding a new DEX (Zeta, Hyperliquid, etc.) requires implementing one interface and registering it; the core trading engine, bot logic, and UI never change. Built in response to the Drift Protocol exploit to ensure the platform is never locked to a single venue again.
- Pacifica.fi Native Integration — Full integration with Pacifica perpetuals: WebSocket-driven fills, REST reconciliation, on-chain Anchor CPI deposits, per-bot keypair-based subaccount isolation, and 8-step canonical JSON request signing. Operates within Pacifica's 300-credit / 60-second rate budget via a centralized rate-limit plane.
- Execution Infrastructure for AI Agents — Any autonomous agent can trade Solana perps through a simple webhook API with a published skill.md-compatible interface.
- Self-Sustaining AI Agent Economy — AI agents create signal bots, attract subscribers through profitable performance, earn on-chain USDC profit share from subscriber trades, and use those earnings to fund their own compute and operating costs — a fully autonomous economic loop on Solana.
- On-Chain Signal Marketplace — Users and agents publish trading signals, others subscribe with proportional copy-trading, and creators earn immediate on-chain USDC profit share.
- Built Through Human-AI Collaboration — Architected and implemented using AI agents (Claude, Gemini Pro 3, Grok Code Fast 1, ChatGPT Codex 5.2), guided by a Solana DeFi practitioner with a decade of trading experience, two decades of IT expertise, and five years in Solana DeFi.
Architecture
QuantumVault is built around a ports-and-adapters (hexagonal) pattern. The core never imports an exchange directly — it always goes through the registry.
┌─────────────────────────────────────────────────────────────┐
│ QuantumVault Core │
│ routes.ts · position-service · trade-retry-service │
│ reconciliation-service · pnl-snapshot-job · QuantumLab │
└───────────────────────┬─────────────────────────────────────┘
│ ProtocolAdapter interface
│ (server/protocol/adapter.ts)
┌─────────┴──────────┐
│ AdapterRegistry │
└────┬──────────┬────┘
│ │
┌─────────┴──┐ ┌────┴────────┐
│ Pacifica │ │ Drift │
│ (primary) │ │ (backup) │
└────────────┘ └─────────────┘
Key components in server/protocol/:
adapter.ts — ProtocolAdapter and UserTransactionBuilder interfaces every exchange implementsadapter-registry.ts — Per-bot adapter resolution; supports global default and per-bot overridessymbol-registry.ts — Bidirectional symbol mapping between QuantumVault's internal naming (SOL-PERP) and each exchange's formatadapter-health.ts — Generic health tracker for any adapterpacifica/ — Pacifica adapter, signer, WebSocket manager, transaction builder, typesdrift/ — Drift adapter wrapping the existing Drift service behind the same interface
What an adapter owns:
| Capability | Adapter Responsibility |
|---|
| Authentication | Sign requests in the exchange's required format (Pacifica: 8-step canonical JSON + Ed25519) |
| Market data | getMarkets, getPrice, getOrderbook, getFundingRate |
| Account state | getPositions, getBalances, getAccountInfo |
| Order execution | placeMarketOrder, placeLimitOrder, cancelOrder, closePosition |
| Subaccounts | Create / list / transfer between (model varies: keypair-based on Pacifica, numeric ID on Drift) |
| Capital flows | On-chain deposit (via UserTransactionBuilder), REST-based withdraw |
The core never asks "what exchange is this?" — it asks the registry, gets an adapter, and calls the interface. This is what made the post-Drift-hack pivot possible without rewriting the trading engine.
See docs/ADDING_EXCHANGE_ADAPTERS.md for the full guide on implementing a new adapter, and docs/SMART_ROUTING.md for the planned automatic-routing layer.
How Solana Is Used
| Feature | Solana Integration |
|---|
| Trade Execution | Pacifica.fi REST + WebSocket (primary); Drift Protocol via the adapter layer (backup). All exchange-side; Solana RPC not in the hot path. |
| On-Chain Capital | USDC deposits to Pacifica via Anchor CPI; user-signed deposit, agent-signed withdraw. Drift deposits via the SDK when that adapter is selected. |
| Position Management | Exchange WebSocket is the source of truth; database acts as cache with reconciliation against REST every 60 seconds. |
| Agent Wallets | Server-managed Solana wallets per user with AES-256-GCM encrypted private keys for autonomous execution. |
| Subaccount Isolation | Each bot operates on its own isolated subaccount — keypair-based on Pacifica (encrypted per-bot private key in DB), numeric ID on Drift. |
| Token Operations | Automated USDC deposits, withdrawals, and profit distribution via the SPL Token program. |
| Profit Sharing | Immediate on-chain USDC transfers to signal creators when subscriber trades close profitably. |
How the AI Agent Operated Autonomously
The AI agents autonomously handled:
- Full-stack architecture and implementation (React/TypeScript, Express, PostgreSQL via Drizzle ORM)
- Design and rollout of the protocol-adapter layer in response to the Drift Protocol exploit
- Pacifica.fi adapter, signer, WebSocket manager, deposit transaction builder, and subaccount isolation
- Wrapping the legacy Drift service behind the same
ProtocolAdapter interface so it could remain registered as a backup
- TradingView webhook system for automated signal processing
- Signal marketplace with subscriber copy-trading and proportional trade sizing
- Creator profit-sharing system with on-chain USDC transfers
- Security architecture (UMK key derivation, execution authorization, policy HMAC, per-bot keypair encryption)
- Production debugging across both protocols, including post-migration onboarding edge cases (
provisionFundedSubaccount flow)
- Telegram notification system
- AI agent integration documentation and skill interface
- Continuous deployment and maintenance on Solana mainnet
The human operator provided strategic direction, product vision, trading domain expertise, and orchestrated the multi-agent workflow. Neither could have built this alone.
AI Agent Infrastructure
QuantumVault serves as execution infrastructure for autonomous AI agents to trade Solana perpetual futures:
Webhook API — Any agent sends a simple POST request to open, close, or flip positions:
# Open a long position
curl -X POST https://myquantumvault.com/api/webhook/{BOT_ID} \
-H "Content-Type: application/json" \
-d '{"botId": "{BOT_ID}", "action": "buy", "contracts": "10", "position_size": "100"}'
# Close position
curl -X POST https://myquantumvault.com/api/webhook/{BOT_ID} \
-H "Content-Type: application/json" \
-d '{"botId": "{BOT_ID}", "action": "sell", "contracts": "0", "position_size": "0"}'
What the agent gets: Routed execution through whichever adapter the bot is bound to (Pacifica by default), automatic retry with exponential backoff, RPC failover (Helius + Triton) for the on-chain deposit/withdraw path, margin management, auto top-up between agent and bot subaccounts, and position tracking — without needing to know anything about the underlying exchange.
The self-sustaining loop: An AI agent creates a signal bot, publishes it to the marketplace, and begins trading. As its track record grows, human users and other agents subscribe. When subscriber trades close profitably, the creator agent earns a percentage via immediate on-chain USDC transfer. Those earnings can fund the agent's own compute and trading capital — creating a fully autonomous economic actor on Solana that sustains itself through trading performance.
Tech Stack
- Frontend: React 18, TypeScript, Wouter, TanStack React Query, Tailwind CSS v4, shadcn/ui, Framer Motion, Solana Wallet Adapter
- Backend: Node.js, Express.js, TypeScript, ESM modules
- Database: PostgreSQL via Drizzle ORM
- Protocol Layer:
server/protocol/ — ProtocolAdapter interface, AdapterRegistry, SymbolRegistry, per-exchange adapter packages
- Exchanges: Pacifica.fi (primary, REST + WebSocket + Anchor CPI deposits), Drift Protocol (backup adapter)
- Blockchain: Solana Web3.js, SPL Token,
@coral-xyz/anchor for Pacifica deposits, tweetnacl / @noble/ed25519 for Pacifica signing
- RPC: Helius (primary) + Triton (failover), used only for on-chain deposit / withdraw
Getting Started
Prerequisites
- Node.js 20+
- PostgreSQL database
- Solana RPC endpoint (Helius recommended) — only required for the on-chain deposit/withdraw path
- Phantom Wallet (for user-facing features)
Environment Variables
DATABASE_URL=postgresql://...
SESSION_SECRET=your-session-secret
HELIUS_API_KEY=your-helius-key
SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=...
SOLANA_NETWORK=mainnet-beta
AGENT_ENCRYPTION_KEY=your-64-char-hex-key
SERVER_EXECUTION_KEY=your-64-char-hex-key
Installation
# Install dependencies
npm install
# Push database schema
npm run db:push
# Start development server
npm run dev
The application will be available at http://localhost:5000.
Production
The platform is deployed and running in production at myquantumvault.com.
Features
- Trading Bots — Deploy automated perpetual futures bots on any market the active adapter supports (Pacifica covers SOL, BTC, ETH, and 60+ other perps)
- Protocol-Agnostic Routing — Bots can be bound to a specific adapter, or run on the global default; the registry handles the rest
- Per-Bot Subaccount Isolation — Each bot has its own isolated subaccount with its own encrypted keypair (Pacifica) for true margin separation
- Signal Marketplace — Publish and subscribe to trading signals with proportional copy-trading
- Profit Sharing — Creators earn on-chain USDC when subscriber trades profit
- Real-Time Dashboard — Live positions, PnL tracking, account health, and fee monitoring
- Agent Wallets — Server-managed wallets with encrypted key storage for autonomous execution
- QuantumLab — Pine Script strategy backtesting and parameter optimization, with results that mirror the live execution path
- Telegram Notifications — Configurable alerts for trades, errors, and position changes
- AI Agent API — Webhook interface for autonomous agents to trade Solana perps
Security
- AES-256-GCM encryption for all private keys (user agent wallets and per-bot subaccount keys)
- User Master Key (UMK) derivation per user
- Per-bot keypair binding with on-startup invariant checks (decrypted key must match stored public key)
- Policy HMAC for bot configuration tamper detection
- Execution authorization via wallet signature
- Rate-limited seed phrase reveal
- No sensitive key material in logs
License
MIT
