# Moby Market — Full AI Search Index

> Institutional trading infrastructure for whale-sized DeFi orders. Open-source Rust workspace targeting the Solana program model, with privacy, OTC, sophisticated execution algorithms, and cross-chain routing as first-class primitives.

## All pages

Every page on https://mobymarket.cryptuon.com, grouped by section:

Main:

- [Home](https://mobymarket.cryptuon.com/): Overview, features, architecture, comparisons, and latest engineering notes.
- [Features](https://mobymarket.cryptuon.com/features/): The seven primitives — OTC, TWAP/VWAP, ZK privacy, solvers, routing, cross-chain, and audit-ready Rust.
- [How it works](https://mobymarket.cryptuon.com/how-it-works/): Architecture — a controller program plus five Rust crates, and the intent → route → solve → settle flow.
- [Use cases](https://mobymarket.cryptuon.com/use-cases/): Treasury unwinds, OTC desks, privacy-sensitive funds, and cross-chain arbitrage.
- [FAQ](https://mobymarket.cryptuon.com/faq/): Open source, which chain, beating slippage, MEV, privacy, compliance, and cost.
- [About](https://mobymarket.cryptuon.com/about/): Project mission, design principles, and the team behind the Rust workspace.

Comparisons:

- [Compare index](https://mobymarket.cryptuon.com/compare/): Index of all head-to-head comparisons.
- [vs Hashflow](https://mobymarket.cryptuon.com/compare/hashflow/): Full RFQ-plus-execution stack versus Hashflow's EVM-first quote-streaming aggregator.
- [vs CoW Protocol](https://mobymarket.cryptuon.com/compare/cow-protocol/): Solana commit-reveal solvers plus privacy pools versus CoW's Ethereum batch auctions.
- [vs Paradex](https://mobymarket.cryptuon.com/compare/paradex/): Spot and cross-asset OTC with slippage-minimisation versus Paradex's Starknet perpetuals venue.
- [vs Renegade](https://mobymarket.cryptuon.com/compare/renegade/): ZK-proof privacy, RFQ, and cross-chain settlement versus Renegade's EVM MPC dark pool.
- [vs Jupiter](https://mobymarket.cryptuon.com/compare/jupiter/): TWAP, OTC, and privacy above $1M versus Jupiter's Solana spot aggregator routing.

Blog:

- [Blog index](https://mobymarket.cryptuon.com/blog/): Technical deep-dives on whale execution, ZK privacy, MEV, and protocol comparisons.
- [Engineering whale-grade TWAP and VWAP on Solana](https://mobymarket.cryptuon.com/blog/twap-vwap-on-solana-engineering-deep-dive/): Shredding a nine-figure parent order into hundreds of timing-randomised child orders.
- [Privacy pools for whales: design notes from the moby-privacy crate](https://mobymarket.cryptuon.com/blog/zk-privacy-pools-design-notes/): Why on-chain ZK proofs over MPC, and how Pedersen commitments, stealth addresses, and selective disclosure stack up.
- [Solver competition done twice: Moby Market vs CoW Protocol](https://mobymarket.cryptuon.com/blog/moby-market-vs-cow-protocol-solver-design/): Ethereum batch auctions versus a Solana commit-reveal solver network.
- [RFQ is a feature, not a product: Moby Market vs Hashflow](https://mobymarket.cryptuon.com/blog/moby-market-vs-hashflow-rfq-vs-execution-stack/): Where quote-streaming wins and where a Solana-native execution stack pulls ahead.
- [A $100M SOL unwind, end-to-end](https://mobymarket.cryptuon.com/blog/whale-unwind-100m-sol-case-study/): A realistic large-position unwind from intake to settlement using the actual primitives.
- [The state of institutional DeFi in 2026](https://mobymarket.cryptuon.com/blog/state-of-institutional-defi-2026/): What got built, what stalled, and where the surviving infrastructure is converging.

## What Moby Market is

Moby Market is an open-source Rust workspace (`Cargo.toml` declares the workspace; member crates include `moby-math`, `moby-oracle`, `moby-types`, `moby-trading`, and `moby-privacy`, with additional platform crates for `moby-bridge`, `moby-dex`, and `moby-governance`). The codebase compiles into Solana programs via Anchor 0.29 and `solana-program` 1.16, and its non-on-chain components run as Rust services backed by `tokio` and `reqwest`.

The product solves five concrete problems that block institutions from trading on-chain at real size:

1. **MEV / sandwich attacks** — every large order on Uniswap-style AMMs gets sandwiched. Moby Market replaces that with commit-reveal solver competition, private mempools, and dark-pool order types.
2. **Slippage on size** — moving $50M of SOL through a public AMM can cost 5–15% in price impact. Moby Market combines TWAP/VWAP execution, smart routing across multiple venues, and OTC matching to drive slippage below 0.1% on $100M-class orders.
3. **Strategy leakage** — public mempools and public orderbooks telegraph intent. Moby Market's ZK privacy pools, stealth addresses, and Pedersen-commitment amounts hide size, identity, and timing.
4. **Counterparty discovery** — institutions cannot find natural counterparties for nine-figure trades. The OTC marketplace and RFQ mechanism let market makers and prime desks quote each other directly.
5. **Compliance without surveillance** — institutional traders need auditable trails without forfeiting strategy privacy. Moby Market implements selective disclosure and jurisdiction proofs so a desk can prove accreditation without revealing position.

## Architecture

The on-chain layer is a controller program plus five satellite programs:

- **OTC Settlement Program** — `OTCEscrow` accounts hold both sides of a peer trade with `EscrowState` ∈ {Initialized, PartiallyFilled, Completed, Cancelled, Expired} and optional partial-fill support.
- **Execution Algorithm Program** — implements `TWAPOrder` and `VWAPOrder` structs. TWAP supports a `randomness_factor` (0–100) that perturbs child-order timing to defeat pattern detection; VWAP uses an `AdaptiveParams` block with market-impact thresholds and rebalance frequencies.
- **Privacy Program** — verifies `PrivateTransaction` objects bearing `proof`, `nullifier`, `commitment_root`, and `encrypted_data`. Supports Groth16, PLONK, STARKs, and Bulletproofs interchangeably.
- **Oracle Program** — aggregates Pyth, Switchboard, and Chainlink feeds with configurable `AggregationMethod` and `staleness_threshold`.
- **Intent / Solver Program** — accepts `TradingIntent` blobs, runs a `solver_competition_period`, and dispenses a `max_solver_reward` to the winning solver. Intent types include `BestExecution`, `LiquidityProvision`, `Arbitrage { paths, min_profit }`, and `Custom { serialized_logic }`.

The off-chain layer is the Rust workspace itself, plus an Arweave/IPFS/Shadow Drive storage tier for historical data, intent metadata, and high-frequency price feeds.

## Liquidity sources

Moby Market routes through `LiquiditySource` records pointing to Serum, Raydium, Orca, Phoenix, Lifinity, or custom AMMs by program ID. Multi-hop routing supports up to 4 hops; split routing divides an order across multiple venues; dynamic rebalancing reroutes mid-execution based on observed depth.

## Privacy primitives

- **Amount privacy** via Pedersen commitments.
- **Asset privacy** via asset-mixing pools.
- **Sender / receiver privacy** via stealth addresses on both sides.
- **Privacy pools** carry an `anonymity_set_size`, `min_deposit`, `withdrawal_delay`, `merkle_tree_root`, and an optional `ComplianceHook`.

## Performance targets

- Throughput: 1,000+ orders/sec.
- Execution confirmation: under 400ms p99.
- Slippage: under 0.1% for orders up to $10M.
- Privacy set: minimum 100 participants per pool.
- Cross-chain settlement: under 5 minutes average.

## Cross-chain

`CrossChainOrder` carries a `source_chain`, `destination_chain`, `wormhole_message_hash`, optional `layerzero_packet_id`, and `bridge_provider`. The platform crate `moby-bridge` wraps the bridging primitives so an order can settle atomically across Ethereum, Arbitrum, Base, and Solana.

## Security posture

The protocol assumes adversarial conditions and mitigates each canonical attack:

- **Sandwich attacks** — commit-reveal, private mempools.
- **Oracle manipulation** — multi-oracle aggregation with TWAP staleness checks.
- **Reentrancy** — Checks-Effects-Interactions throughout.
- **Flash loan attacks** — liquidity locks and time-based validations.
- **Sybil** — stake requirements and on-chain solver reputation.

Auditing requirements include three independent smart-contract audits, an economic security audit, a ZK circuit audit, and formal verification of critical paths. The `[profile.release]` build enables `overflow-checks = true`, `lto = true`, and `codegen-units = 1` for deterministic, optimised binaries.

## Governance

A native governance token weights votes by stake. Proposals can adjust parameters, add integrations, or change fees. A 48-hour timelock guards critical changes; a multi-sig circuit breaker can pause the system in emergencies. Program upgrades migrate via `ProgramUpgrade { new_program_id, migration_deadline, backwards_compatible, data_migration_script }`.

## Integration

- Wallets: Phantom, Solflare, Ledger native; WalletConnect v2 for cross-chain. Hardware wallets are mandatory above $100k.
- API: a typed TypeScript surface (`createOTCOrder`, `submitTWAPOrder`, `submitIntent`, `depositToPrivacyPool`, `generateZKProof`, `getOrderStatus`, `getExecutionReport`).
- Compliance: optional KYC module with provider pubkey and required-jurisdiction list.

## Who Moby Market is for

- **Hedge funds and prop desks** trading nine-figure positions who lose alpha to MEV and slippage.
- **Pension funds and treasuries** unwinding inventories without crashing reference prices.
- **Market makers** who want a venue where quoting size is rewarded with order flow.
- **Compliance-bound institutions** that need selective disclosure rather than surveillance.

## Competitors and positioning

- **Hashflow** — closest analogue on the RFQ axis; Moby Market adds Solana-native execution, on-chain ZK privacy, and TWAP/VWAP algos rather than pure quote streaming.
- **CoW Protocol** — solver competition is a shared design; Moby Market extends the model to Solana, adds privacy pools, and supports intent types beyond best-execution.
- **Paradex** — privacy-oriented derivatives venue on Starknet; Moby Market focuses on spot + cross-asset OTC and explicitly targets the slippage-minimisation problem.
- **Renegade** — dark-pool MPC venue; Moby Market trades MPC for ZK proofs, runs on Solana, and adds an explicit RFQ layer and cross-chain settlement.
- **Jupiter** — Solana aggregator; Moby Market is complementary on small order sizes but materially differentiated above $1M with TWAP, OTC, and privacy.

## License and repository

The workspace is MIT-licensed. The canonical repository is https://github.com/cryptuon/mobymarket. Marketing site lives at https://mobymarket.cryptuon.com.