We are happy to announce the alpha launch of StarkDEX — the first deployed implementation of our STARK scalability engine, built in collaboration with 0x.

# What is StarkDEX?

StarkDEX is a scalability engine for decentralized exchanges (DEX), which removes the glass ceiling that caps their scale and liquidity, putting them performance-wise on par with centralized exchanges, while still preserving users’ self-custody of assets traded.

Due to the cost of executing every settlement on chain, a DEX cannot settle more than 3 trades/second (even if it were to consume all gas). With StarkDEX, DEXes can settle over 8,000 trades per Ethereum block, or 550 trades per second, an almost 200X improvement over Ethereum’s current peak capacity!

How is this done? StarkDEX processes off-chain the lion’s share of the settlement computation and submits to the blockchain a transparent (requiring no trusted setup) and succinct proof of the integrity of the computation and the correctness of the settled batch of trades.

# What’s in the Alpha? Settling Live Binance Trades at Scale

The Alpha release of StarkDEX is deployed on an Ethereum testnet. This coming week we will use a simulator to replay and settle through our systems a sample of live trades from Binance, the largest crypto exchange in the world in terms of volume: StarkDEX will batch them in real time, compute off-chain proofs of the validity of these batched trades, and verify the proofs on-chain using our StarkDEX verifier smart contract. To demonstrate StarkDEX’s unparalleled ability to handle scale, we plan to accommodate rates of up to 10 trades/second (without adversely affecting the network).

The flow through the StarkDEX system:

- The DEX (or in the alpha, the simulator) sends user-signed trades to be settled to StarkDEX Service to be included in a batch. (In the alpha those trades are a set of live trades from Binance).
- The StarkDEX Service checks that the signatures are valid and that the trades can be executed properly and updates the token balances in the off-chain state.
- Once a batch has filled up, the StarkDEX Service generates a proof attesting to the computational integrity of the entire batch and sends the proof along with the state root to the on-chain Verifier Contract.
- The on-chain Verifier Contract receives a request to change the state — as represented by the new state root — along with the proof. The contract verifies the proof and only then accepts the state transition. Since a proof for an invalid state transition cannot be generated (more precisely: generating it is computationally infeasible), only valid state transitions are accepted.

# What’s Next?

The Alpha launch is another important step in our ongoing journey from an academic paper to a product used by live users. The next steps are deploying a StarkDEX MVP on mainnet while in parallel developing StarkExchange — a self-custodial trading solution for centralized exchanges.

# Read More

- Our presentation at ZK-Summit on STARK-based scalability solutions
- STARK Math — our 5-part series diving into the mathematical concepts behind STARKs (parts I, II, III, IV and V)
- FAQs — everything you need to know about StarkDEX
- Our friends at 0x also wrote a post about this joint effort

**StarkWare Sessions**

Join us at the StarkWare Sessions conference, to be held in Tel-Aviv on Sep 16th 2019 (right after Scaling Bitcoin), where we will discuss STARKs as a Layer-2 (and Layer-1) scalability solution, as well as STARK-friendly hash functions.