OmniCurve

One continuous curve instead of a hundred yes/no pools — a Gaussian-priced prediction market, with all the math running on-chain via Arbitrum Stylus.

비디오

기술 스택

Rust

Web3

React

Node

Solidity

Stylus

Goldsky

Websockets

설명

OmniCurve : A prediction market protocol based on the distribution market paper by Paradigm, where a prediction pool on an asset with a numerical outcome does not divide prediction pools into a thousand different binary pools with fragmented liquidity.

Predict - https://omnicurve.vercel.app

WhitePaper of the protocol -
https://github.com/PhAnToMxSD/OmniCurve/blob/main/docs/Whitepaper.md

The presentation - https://www.canva.com/design/DAHMcIwxJlE/eAT9eq0MIKq6Ko6A1uO2Mg/edit

Inspiration of the Project-

Prediction markets today are great at binary questions but clumsy at continuous ones. If you want to bet on where ETH lands at the end of 2026, platforms like Polymarket make you pick from a handful of separate YES or NO pools with one at 4k dollars, one at 5k dollars, and so on. Each of those pools needs its own liquidity and its own market makers, so capital ends up spread thin, only a few strike prices ever get listed, and the market can never really express a full distribution of belief. There is a big difference between "this will take exactly 10 years" and "somewhere between 2 and 20 years," and the binary pool model just cannot say that.

The Fix -

OmniCurve collapses the whole outcome space into a single continuous liquidity curve.
The price of a bet at any strike comes straight from the cumulative distribution function over a Gaussian defined by a mean μ, the market's consensus expectation, timelock so there is a dispute window before anything finalize.
So bet ETH ends above 7k dollars? We price it off the curve instantly, no new pool required. And μ and σ are not set by an admin, they are a stake weighted aggregate of every bet ever placed, kept on-chain through three running accumulators that update in O(1) per trade.
Bettors move the curve, liquidity providers do not, so LPs earn fees but can't shift the consensus, which kills a whole class of manipulation. Settlement is judged against the real-world outcome at each position's own strike, never against what the market believed, so dragging μ around can't change who wins.
All of this leans on Arbitrum Stylus. A Gaussian CDF means an error-function approximation, a Taylor-series exponential, and a Newton's-method square root, 150–200 fixed-point operations per timelock so there is a dispute window before anything finalizesnce compiled to WASM and run in Rust.
What is live on Arbitrum Sepolia is a full vertical slice, not a mock-up: four feature-gated Rust contracts (an AMM holding curve state and collateral, a Router doing pricing and settlement, an LP token, and an EIP-1167 factory that clones a fresh market trio per question), a backend that indexes on-chain events off a Goldsky subgraph and pushes live curve updates over WebSockets, and a React + d3 "quant terminal" that draws the belief curve as it breathes.
Fees reach LPs through a MasterChef-style accumulator that stays O(1) no matter how many providers there are, and resolution runs through a two-phase 24-hour timelock so there's a dispute window before anything finalizes.

해커톤 진행 상황

OmniCurve was built entirely from scratch during the buildathon, no prior codebase. We started from the math and worked outward. First we wrote the full Gaussian engine in Rust from zero, fixed-point arithmetic, an error-function approximation, a Taylor-series exponential, and a Newton's-method square root, composed into a normal cumulative distribution function. This was the riskiest piece, so we built and tested it first. On top of it we built four contracts: the AMM, the Router, a non-transferable LP token, and a factory. The factory was a genuine fight, Stylus does not give you CREATE2, so we hand-assembled the minimal proxy bytecode and matched it byte-for-byte against the bytecode of the implementation by OpenZepplin to be sure. We also pulled off a single-crate, four-binary trick so we never duplicated the math module. Mid-build we landed the core insight that bettors move the curve and LPs do not, and reworked the call ordering around it, pricing a trade against the curve before that trade shifts it. Then we deployed everything with some live markets to Arbitrum Sepolia, with an Express + Socket.io backend, a subgraph and Postgres for indexing, and a React frontend that renders the live curve in real time. In the back half we went through the edge cases methodically, divide-by-zero, negative variance, reentrancy guards on every fund-moving function, since a panic in a Stylus contract burns the whole transaction's gas. By the end we had a complete, deployed, working slice, with trust-minimization and richer order types scoped as what comes next.

자금 모금 상태

Currently bootstrapped and actively seeking pre-seed funding or grant opportunities to scale our prototype, conduct further security audits, and expand our initial pilot.

팀 리더

TTathagat Gupta

프로젝트 링크

부문

DeFiInfraOther