Skip to content

Latest commit

 

History

History
319 lines (233 loc) · 9.76 KB

PITCH.md

File metadata and controls

319 lines (233 loc) · 9.76 KB

Building an Options Protocol on Aptos

Project Proposal & Research

The Idea

I want to build the first native options trading protocol on Aptos—a decentralized platform where users can trade BTC and ETH options without leaving the Aptos ecosystem.

I've done the research, built a working prototype, and believe this is a significant opportunity. Here's why.

Why This Makes Sense

1. The Market is Massive, DeFi Capture is Tiny

Metric Value
Global crypto options volume $1.5T+ annually
Percentage on CEXs (Deribit, OKX) 95%+
DeFi options TVL (all chains) ~$500M
Options protocols on Aptos Zero

The crypto options market is enormous, but almost entirely centralized. DeFi has barely scratched the surface, and Aptos—despite $800M+ in DeFi TVL—has no options infrastructure at all.

2. Aptos is Uniquely Suited for This

Performance: 160,000 TPS with sub-second finality. Options trading requires speed—Ethereum L1 can't deliver this, and even L2s have latency issues.

Security: Move's resource-oriented model eliminates entire classes of bugs:

  • No re-entrancy attacks (resources can't be duplicated)
  • No double-exercise (positions are consumed on settlement)
  • Compile-time safety guarantees vs runtime checks

Ecosystem timing: The infrastructure we need exists:

  • Pyth oracles are live on Aptos (real-time BTC/ETH prices)
  • Hyperion DEX provides orderbook infrastructure
  • Active DeFi community looking for advanced instruments

3. Existing DeFi Options Have Problems

Protocol Issue
Lyra, Premia AMM model = poor pricing for illiquid options
Dopex Single-sided vaults limit flexibility
Ethereum-based High gas, slow finality, poor UX
All of them Not on Aptos = users must bridge out

An Aptos-native solution with orderbook-based pricing solves these problems.

What I'm Proposing to Build

The Product

A protocol where users can:

  1. Buy call/put options on BTC and ETH
  2. Sell options to earn premium income
  3. Settle automatically at expiry (cash-settled in USDC)

Simple, focused, and covering the core use case before expanding.

User Experience

For a buyer:

Connect wallet → Pick "BTC $50k Call expiring March 28" →
Place buy order → Pay premium → Hold until expiry →
Receive payout automatically if profitable

For a seller:

Deposit USDC collateral → Pick same option →
Place sell order → Receive premium when filled →
Get remaining collateral back at settlement

Technical Approach

I'm proposing a modular architecture:

┌─────────────────────────────────────────────────────────────────┐
│                     OPTIONS PROTOCOL                            │
│                                                                 │
│   Core Logic          Infrastructure         Integrations       │
│   ───────────         ──────────────         ────────────       │
│   • Options Engine    • Collateral Vault     • Pyth Oracle      │
│   • Series Manager    • Margin Calculator    • Hyperion DEX     │
│   • Settlement        • Pricing Engine       • Events/Indexing  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Key design decisions:

Decision Choice Rationale
Option style European Simpler settlement (exercise at expiry only)
Collateral Full (125%) Safe for MVP, no liquidation complexity
Price discovery Orderbook (Hyperion) Better than AMM for illiquid options
Settlement Cash (USDC) No physical delivery complexity
Oracle Pyth Already live on Aptos, trusted

Proof of Concept: What I've Already Built

I didn't want to pitch just an idea—I wanted to validate that this is technically feasible. So I built a working prototype.

Current State

Component Status
Smart contracts 14 Move modules, compiling
Test coverage 87 tests passing
Core features Options, settlement, collateral, margin
Deployment Ready for testnet

What the Prototype Includes

Complete modules:

  • types.move - Position structs, option series definitions
  • math.move - Fixed-point arithmetic, Black-Scholes math
  • oracle.move - Pyth integration, volatility calculation
  • collateral.move - USDC vault management
  • series.move - Option series lifecycle
  • margin.move - Collateral requirement calculations
  • pricing.move - Black-Scholes option pricing
  • settlement.move - Cash settlement engine
  • orderbook.move - Hyperion DEX integration
  • Plus supporting modules (config, events, errors, liquidation)

Test coverage breakdown:

Test Suite Tests What it Validates
Math 32 Fixed-point operations, exp/ln, sqrt
Types 18 Data structures, position management
Margin 19 Collateral calculations, ITM/OTM logic
Integration 18 Full option lifecycle, cross-module flows

Example: Full trade scenario test

1. Create BTC call option (strike $48k, expiry in 24h)
2. Writer deposits collateral (125% of max loss)
3. At settlement, BTC is at $55k
4. Payout calculated: ($55k - $48k) × contracts = $7k
5. Writer gets remaining collateral, buyer gets payout

This all works. The prototype proves the core mechanics are sound.

Business Model

Revenue Streams

Stream Rate Notes
Trading fee 0.30% On every trade
Settlement fee 0.15% On exercised options
Liquidation penalty 5% Goes to liquidators + protocol

Rough Economics

At $10M daily volume (conservative target):

  • Trading fees: $30k/day
  • Settlement fees: ~$4.5k/day (assuming 30% ITM)
  • Monthly revenue: ~$1M

These numbers scale with volume. Deribit does $1B+ daily—even capturing 1% of that flow would be significant.

Roadmap

Phase 1: Foundation (Done)

  • Core smart contracts
  • Comprehensive test suite
  • Technical architecture validated

Phase 2: Testnet (3 months)

  • Deploy to Aptos testnet
  • Build basic frontend
  • Integrate live Pyth feeds
  • Connect Hyperion orderbook
  • Community testing

Phase 3: Mainnet (3 months)

  • Security audit (2 firms)
  • Mainnet deployment
  • Initial liquidity (market maker partnerships)
  • Launch

Phase 4: Growth (6 months)

  • Portfolio margin (capital efficiency)
  • Additional assets (SOL, APT)
  • Advanced features

What I Need

To Get to Testnet

  • 2-3 months focused development
  • Frontend developer (React/TypeScript)
  • Design resources for UI/UX

To Get to Mainnet

  • Security audits (~$100-200k for 2 reputable firms)
  • Initial liquidity for market making
  • Legal review

Funding Allocation (Proposed)

Category % Purpose
Engineering 50% Core team (Move + Frontend)
Security 20% Audits, bug bounties
Liquidity 15% Market making, LP incentives
Operations 10% Legal, infra, tools
Marketing 5% Launch, community

Risks & Mitigations

Technical

Risk Mitigation
Smart contract bugs Multiple audits, extensive testing (87 tests already), bug bounties
Oracle manipulation Pyth's decentralized network, price sanity checks
Liquidation cascades Conservative 125% collateral ratio

Market

Risk Mitigation
Low initial liquidity Market maker partnerships, incentive programs
Competition First mover on Aptos, Move expertise as moat
Regulatory Cash-settled, non-custodial design

Why Me / Why Now

Why me:

  • Built a working prototype (not just a pitch deck)
  • Deep understanding of options mechanics
  • Experience with Move/Aptos development

Why now:

  • Aptos ecosystem is growing but lacks advanced DeFi
  • Infrastructure (Pyth, Hyperion) just became available
  • Window to establish first-mover advantage

Ask

I'm looking for:

  1. Feedback on the approach and architecture
  2. Funding to take this from prototype to mainnet
  3. Connections to potential market makers, auditors, or team members

The prototype is built. The research supports the opportunity. I'm ready to execute.

Appendix

A. Technical Details

Collateral Formula:

Short Call: max(spot_price, strike) × contracts × 1.25
Short Put:  strike × contracts × 1.25

Settlement Payout:

Call: max(0, settlement_price - strike) × contracts
Put:  max(0, strike - settlement_price) × contracts

B. Competitive Landscape

Protocol Chain Model Our Advantage
Lyra Arbitrum AMM Orderbook = better pricing
Dopex Arbitrum Vaults More flexible positions
Premia Multi AMM Aptos performance
Aevo Optimism Orderbook Native Aptos, Move security

C. Code Repository

The prototype is available for review:

  • 14 Move modules (~3,800 lines)
  • 87 passing tests
  • Full documentation

D. Glossary

  • Call option: Right to buy at strike price
  • Put option: Right to sell at strike price
  • ITM (In The Money): Option has intrinsic value
  • OTM (Out of The Money): Option expires worthless
  • Premium: Price paid for the option
  • European style: Can only exercise at expiry

Last updated: December 2024