Private On-Chain OTC Protocol for Bitcoin Block Trades on Starknet

VB Desk is a private, verifiable over-the-counter (OTC) trading protocol built on Starknet. It introduces sealed-bid batch auctions to the on-chain OTC market — a mechanism that eliminates front-running, conceals order intent until execution, and produces cryptographically verifiable, deterministic clearing outcomes.

At its core, VB Desk operates through a commit-reveal-clear-settle cycle. Participants submit cryptographic commitments to their orders, reveal them within a time window, and receive fills determined by a deterministic matching engine — all with on-chain settlement and Merkle-proof-based claims.

The protocol solves four critical problems in today's OTC market: front-running and MEV (via commit-reveal), strategy leakage (via private notes), unverifiable clearing (via deterministic algorithms + Merkle roots), and fragmented liquidity (via batch auctions).

┌──────────────────────────────────────────────────┐
│                Frontend (React)                  │
│  Landing Page │ Auction List │ Auction Detail     │
│  Create Auction │ My Bids │ Wallet Integration    │
└──────────────────────┬───────────────────────────┘
                       │ REST API / WebSocket
                       ▼
┌──────────────────────────────────────────────────┐
│                  Backend (NestJS)                 │
│     Commit · Reveal · Batch · Clearing Engine     │
└─────────┬────────────────────────┬───────────────┘
          │ PostgreSQL             │ Starknet RPC
          ▼                        ▼
  ┌──────────────┐      ┌─────────────────────┐
  │   Database   │      │      Starknet       │
  └──────────────┘      │  Vault.cairo        │
                        │  Settlement.cairo   │
                        │  NoteRegistry.cairo │
                        └─────────────────────┘

Each auction operates through four sequential phases with strict time-based transitions:

|── COMMIT PHASE ──|── REVEAL PHASE ──|── CLEARING ──|── SETTLED ──|
t0                t1                 t2             t3            t4

1. Commit Phase (t0 → t1) — Participants submit a Poseidon hash of their order (price, quantity, direction, salt, wallet). No order information is visible to any party during this phase.

2. Reveal Phase (t1 → t2) — Participants reveal their actual order. The backend verifies the reveal matches the earlier commitment. Upon successful verification, the participant's tokens are locked in the on-chain Vault as collateral:

• BUY orders: lock quantity × max_price in quote token (USDC)
• SELL orders: lock quantity in base token (BTC)

3. Clearing (t2 → t3) — The clearing engine executes a deterministic pay-as-bid matching algorithm with multi-price execution:

1. Sort buy orders by price descending, sell orders by price ascending
2. Match crossing orders until no further crosses exist
3. Apply partial fills where allowed
4. Compute individual fill amounts for each matched order
5. Construct a Poseidon Merkle tree of all fill results
6. Publish the Merkle root and clearing price on-chain

4. Settlement & Claims (t3 → t4) — Each participant presents a Merkle proof to claim their filled tokens directly from the Vault. Verifiable receipts are generated so any participant can independently verify the fairness of the entire batch from public data alone.

Participant            Backend                  Starknet
     │                    │                        │
     │── deposit ────────▶│───────────────────────▶│ Vault.deposit()
     │                    │                        │
     │── submit commit ──▶│                        │
     │                    │── store hash + verify  │
     │                    │                        │
     │── submit reveal ──▶│                        │
     │                    │── verify preimage      │
     │                    │── reserve collateral ─▶│ Vault.reserve()
     │                    │                        │
     │                    │── run pay-as-bid       │
     │                    │── build Merkle tree    │
     │                    │── publish batch ──────▶│ Settlement.submit_batch()
     │                    │── publish allocations  │
     │                    │                        │
     │── get proof ──────▶│                        │
     │◀── Merkle proof ───│                        │
     │── claim fill ─────▶│───────────────────────▶│ Settlement.claim_fill()
     │◀── tokens ─────────│◀───────────────────────│ Vault.transfer_to()
     │                    │                        │
     │── withdraw ───────▶│───────────────────────▶│ Vault.withdraw()
     │◀── tokens ─────────│◀───────────────────────│

VB Desk implements a privacy layer that makes depositor identity and trading activity computationally unlinkable:

Built for the Starknet Re{define} Hackathon.

This project is licensed under the MIT License.