How Probio works

Every market you can trade here originates from a real Polymarket event. Probio does not invent markets, prices or volumes. What Probio adds is the execution layer around them: margin, multi-leg parlays, position tracking and a USD-denominated account funded from Robinhood Chain or Solana.

The terminal is usable without an account. Signing in adds a persistent wallet address and syncs your portfolio and settings across devices, but nothing is gated behind it.

Trade as a guest

Open the terminal and start trading immediately. You are given a practice balance and placed in demo mode, which cannot be switched off while signed out. Positions persist in your browser and are lost if you clear site data.

Create an account

Signing in unlocks deposits and the Live/Demo switch. New accounts start in Live mode with a USD balance held on the account ledger, which is zero until funded. Demo becomes an explicit opt-in rather than the default, so practice funds are never confused for real ones.

Deposit

Open Deposit, connect MetaMask (Robinhood Chain) or Phantom (Solana), sign a one-time message proving you own the wallet, then approve the transfer. Stablecoins count at $1.00; ETH and SOL count at the live spot price. Sending an asset on a network other than the one selected will not credit your balance and the funds are not recoverable by Probio.

browser
  |
  |-- /api/markets/*     catalogue, search, history   (cached, ~20.7k markets)
  |-- /api/wallet        ledger balance, verified wallets, history
  |-- /api/deposits      on-chain deposit verification
  |-- /api/withdrawals   withdrawal requests (reviewed)
  |-- /api/live/*        server-executed live orders and positions
  |-- /api/referrals/*   invite codes, attribution, visits, rewards
  |-- /api/sync          portfolio + settings sync    (account holders only)
  |
  v
Polymarket Gamma API  ->  market metadata, resolution state
Polymarket CLOB API   ->  order books, price history
Robinhood Chain RPC   ->  ETH and ERC-20 balances, chain id 4663
Solana RPC          ->  SOL and SPL token balances
CoinGecko           ->  ETH and SOL spot prices for USD valuation

The market catalogue is crawled and stored rather than proxied per request, so browsing 20,000+ markets does not translate into 20,000 upstream calls. Order books and price history are fetched on demand for the selected market only.

Supported assets

An asset is only accepted once its token contract is verified and configured. Assets without one are shown in the deposit dialog as not enabled rather than pointed at an unconfirmed address.

Robinhood Chain

Network

Robinhood Chain

Chain ID

4663

Native asset

ETH, 18 decimals

Stack

Arbitrum Orbit, EVM equivalent

Default RPC

https://rpc.mainnet.chain.robinhood.com

Explorer

https://robinhoodchain.blockscout.com

RPC providers

The bundled endpoint is the public one. It is rate limited and carries no uptime guarantee, which is fine for browsing and wrong for anything production. Alchemy is the recommended provider and exposes Robinhood Chain on both mainnet and testnet:

# mainnet
https://robinhood-mainnet.g.alchemy.com/v2/<API_KEY>
wss://robinhood-mainnet.g.alchemy.com/v2/<API_KEY>

# testnet
https://robinhood-testnet.g.alchemy.com/v2/<API_KEY>

Set yours under Settings → Advanced, or as NEXT_PUBLIC_RPC_URL in the environment. Balance reads are bounded at three seconds so a slow provider degrades to an unknown balance rather than hanging the interface.

Every change to a live balance is a row in the account ledger: verified deposits, withdrawals, and the margin, fees and payouts of live positions. The balance is the sum of those rows; nothing in the browser can change it.

Verified wallets

Before a wallet can fund an account or receive a withdrawal, its owner signs a one-time plain-text message containing a server nonce. Signing is free and authorises no transfer. EVM signatures are checked with verifyMessage (EOAs and ERC-1271 smart wallets); Solana signatures with ed25519. A wallet can belong to one account.

Deposits

credited when, read from chain:
  tx succeeded            Robinhood Chain: mined, Solana: finalized
  recipient               the platform address for that network
  asset                   ETH / USDG (Robinhood Chain), SOL / USDC / USDT (Solana)
  sender                  a wallet verified by the submitting account
value = amount x price    stablecoins 1.00, ETH and SOL at spot when confirmed

A transaction can be credited once, to one account. Deposits sent from an unverified wallet are credited after that wallet is verified and the hash is submitted again.

Withdrawals

A withdrawal is held from the balance as soon as it is requested and reviewed before it is sent, usually within 30 to 60 minutes. Withdrawals can only go to a verified wallet on the selected network. A declined withdrawal is returned to the balance in full. See the Terms of Use, Deposits, Balances and Withdrawals.

Roughly 20,700 markets are indexed. The catalogue is crawled through the events endpoint rather than the markets endpoint, because the latter caps out around 2,000 records. Resolved markets are retained and reachable behind the Resolved filter rather than deleted, so historical positions still render.

Time in force

Every contract settles at either 1 or 0. Bids and asks are quoted in that same unit, so a price is directly readable as an implied probability. The two sides of a binary market are complementary: Yes at 0.34 implies No at 0.66, minus the spread.

Book display

Asks are sorted ascending and bids descending, then both are sliced nearest the spread, so the rows closest to the mid are always the ones on screen. The book is cleared when you switch outcome, so stale depth from the other side is never shown against a new selection.

Matching

remaining = size
cost      = 0
for level in book (best price first):
    take   = min(remaining, level.size)
    cost  += take x level.price
    remaining -= take
    if remaining == 0: break

if remaining > 0:            -> partial fill or reject
average_price = cost / (size - remaining)

Price-time priority applies at each level: equal prices are filled in the order they arrived.

slippage    = (avg_fill - quote) / quote
impact      = (last_level_taken - best_price) / best_price

Thin books on long-dated markets can carry wide spreads. Size is the variable you control: halving your order often more than halves your impact, because you stop reaching into the sparse levels.

shares     = (margin x leverage) / entry_price
notional   = margin x leverage
borrowed   = notional - margin
pnl        = direction x (mark - entry) x shares

Margin is your own capital and the most you can lose on the position. Notional is the exposure that capital controls. P&L is computed on shares, so the leverage multiplier is applied once, at sizing, and never double counted.

maintenance_margin = notional x 0.05        // 5% of exposure

liquidation_price(long)  = entry x (1 - (1/leverage) + 0.05)
liquidation_price(short) = entry x (1 + (1/leverage) - 0.05)

A position is liquidated when its equity falls below the maintenance margin. Closing is attempted against the book first; if the book cannot absorb it, the remainder is taken by the liquidity pool at the mark, and any shortfall is covered by the insurance reserve.

A market order for 3,000 shares does not execute at the quoted price. It executes at the volume weighted average of every price level it consumes, across every venue it touches, plus fees, plus whatever the order itself does to the book while it is being filled. The router exists to make that number as small as it can be made.

Notation

The objective

The router chooses an allocation vector $\mathbf{q}=(q_v{)}_{v\in \mathcal{V}}$ that minimises total expected cost subject to filling the order exactly and breaching nobody's slippage budget:

where $\Lambda (q)$ is the impact the order inflicts on the mark, $\Pi$ is the realised shortfall, $p^{\min }$ is the best price across all venues at decision time, and $\bar{s}$ is the slippage budget. An order whose optimum violates the second constraint is rejected rather than filled worse.

Pipeline

1   TICKET      side, outcome, margin m, leverage l, slippage budget s
2   VALIDATE    0 < p < 1,  m > 0,  l in [1,10],  m(1+rate) + fees <= balance
3   SNAPSHOT    pull books from every venue, timestamp each
4   STALENESS   discard any book older than 400ms, reprice the rest
5   SIZE        solve C(q) = m*l for q by exact inverse (section below)
6   ALLOCATE    water-fill the merged fee-adjusted book -> q*
7   SCHEDULE    if q* exceeds participation cap, slice by Almgren-Chriss
8   RISK        recompute liquidation price, reject if it sits inside 1 sigma
9   COMMIT      submit child orders, collect fills, reconcile residual
10  SETTLE      debit margin + fees, write position, emit fill event

Order books are not continuous. They are finite ladders of $(p_k,s_k)$ pairs with $p_1<p_2<\cdots <p_K$ on the ask side. Define cumulative depth:

An order for $q$ shares consumes every level up to $J(q)$, the first level at which cumulative depth covers the order:

Total cost is the full levels plus a partial fill of the last one:

Convexity

Differentiating (5) gives the marginal cost of one more share, which is simply the price of the level currently being consumed:

Because the ladder is sorted, $p_{J(q)}$ is a non-decreasing step function of $q$. A function whose derivative is non-decreasing is convex, so $C$ is convex and piecewise linear, with kinks exactly at the cumulative depths $D_j$. That single fact is what makes the allocation problem in the next section tractable: a convex objective over a simplex has no local minima to get trapped in, and the greedy solution is the global one.

Ignore impact and risk for a moment and take the core allocation problem from (1). Form the Lagrangian with multiplier $\mu$ on the fill constraint and ${\nu }_v\ge 0$ on non-negativity:

The stationarity condition, using (7), is:

Complementary slackness forces ${\nu }_v=0$ wherever $q_v>0$. So at the optimum every venue receiving flow shares one common fee-adjusted marginal price, and every venue receiving nothing is more expensive at the margin:

Water-filling

Condition (10) has a direct constructive reading. Merge every level from every venue into one ladder keyed on fee-adjusted price:

Sort ascending and consume greedily until the order is filled. The price of the last level consumed is exactly $\mu$. Every level taken is cheaper than $\mu$ and every level left is dearer, which is precisely (10). The greedy fill is therefore not a heuristic. It is the exact solution of the convex program, and any reallocation of a single share from one venue to another moves cost from $\mu$ to something no smaller.

With $K$ levels across $|\mathcal{V}|$ venues, a k-way merge over a binary heap gives the allocation in $\mathcal{O}\left(K\log |\mathcal{V}|\right)$ time and $\mathcal{O}(|\mathcal{V}|)$ space, without ever materialising the merged ladder.

Trading moves the price. The move has two components. Temporary impact is the concession paid for demanding immediacy and decays once the order stops. Permanent impact is the information the order leaks into the mark and does not decay.

Over longer horizons the empirical relationship is concave rather than linear, and the router uses the square root law when sizing against daily volume:

The scheduling trade-off

Executing slowly reduces impact but leaves the remaining position exposed to volatility for longer. Splitting an order into $N$ slices of $n_j$ shares over $T=N\tau$, with $x_j$ shares still outstanding at step $j$, the shortfall has mean and variance:

Minimising $\mathbb{E}[\Pi ]+\lambda \mathrm{Var}[\Pi ]$ yields a linear difference equation whose solution is a hyperbolic sine trajectory. Writing $\hat{\eta }=\eta -\frac{1}{2}\gamma \tau$, the decay rate $\kappa$ solves:

and the optimal holdings path is:

The model requires $\hat{\eta }>0$, that is $\eta >\gamma \tau /2$. If permanent impact dominates over a slice, spreading the order cannot help and the scheduler falls back to a single sweep. As $\lambda \to 0$ the trader stops pricing risk, $\kappa \to 0$, and (16) degenerates to the straight line $x_j=X(1-t_j/T)$, which is TWAP. Risk aversion is exactly what bends the schedule forward.

Worked schedule

For $X=3,000$ shares over $T=300\text{s}$ in $N=10$ slices, with $\sigma =0.0042$, $\eta =2.5\times 10^{-5}$, $\gamma =5\times 10^{-7}$ and $\lambda =2.5\times 10^{-5}$, equation (15) gives $\kappa =0.005015{\text{s}}^{-1}$, a half-life of 199 seconds:

The first slice is 2.20 times the last. A TWAP would have placed a flat 10% in every bucket. The front loading is the model buying certainty early, because shares still outstanding at minute four carry four minutes of variance and the ones sold in minute one carry none.

A trader posting margin $m$ at leverage $\ell$ controls notional $N=m\ell$ and pays fees on the margin, not the notional:

For a MAX order the binding constraint is the balance $B$, less a buffer $b$ for price movement between quote and fill. Solving for the largest admissible margin:

Note the leverage term in the denominator. Raising leverage raises the fee rate, which lowers the affordable margin, which partially offsets the gain in notional. At $B=10,000$ USD, with a $1 buffer:

From notional to shares

The share count is not $N/p_1$. It is the largest $q$ whose sweep cost does not exceed the notional, which means inverting the cost function from (5):

Because $C$ is strictly increasing and piecewise linear, this inverse is exact and computable in one pass over the ladder. Accumulate level cost until the budget is exceeded, then solve the final level linearly:

A naive fixed point iteration $q_{n+1}=m\ell /\bar{p}(q_n)$ also converges, since $\bar{p}$ is non-decreasing, but it needs several passes and lands slightly short. The closed form in (20) is used instead.

A limit order at price $p$ joins a queue behind $Q_{\text{ahead}}$ shares. Two things must happen for it to fill: the mark has to reach the level, and the queue in front has to clear.

Modelling the mark as driftless Brownian motion, the probability it touches a level $\delta$ away within horizon $T$ follows the reflection principle:

Treating consumption of the level as a Poisson process with intensity $\theta$ shares per second, the queue clears through your own size $q$ with probability:

and the two combine to a usable fill estimate:

Adverse selection

Passive fills are not free. Conditional on being filled, the mark has usually moved toward your order and kept going, so the expected markout at horizon $h$ is negative:

The router therefore compares a passive quote against the aggressive sweep on expected value, not on quoted price. Resting is preferred only when the spread captured exceeds the expected adverse markout plus the variance cost of waiting:

function route(order, venues):
    # 1. snapshot and discard stale books
    books = [v.book() for v in venues if v.age_ms < 400]
    if books is empty: reject("no fresh liquidity")

    # 2. merge on fee-adjusted price, lazily, via a heap
    heap = MinHeap(key = level.price * (1 + venue.fee))
    for b in books: heap.push(b.best())

    # 3. water-fill: greedy on the merged ladder is the exact optimum
    remaining = order.shares
    alloc = {}, gross = 0
    while remaining > 0 and heap not empty:
        lvl  = heap.pop()
        take = min(remaining, lvl.size)
        alloc[lvl.venue] += take
        gross            += take * lvl.price
        remaining        -= take
        heap.push(lvl.venue.next_level())     # keep the ladder fed

    # 4. the last price taken is the KKT multiplier
    mu = lvl.price * (1 + lvl.venue.fee)

    # 5. enforce the slippage budget before committing
    vwap = gross / (order.shares - remaining)
    if (vwap - best_price) / best_price > order.max_slippage:
        reject("slippage budget exceeded")
    if remaining > 0:
        reject("insufficient aggregate depth")

    # 6. schedule if the sweep would exceed the participation cap
    if order.shares > PARTICIPATION * visible_depth:
        return almgren_chriss(order, kappa)

    return alloc, vwap, mu

Worked example

Two venues, an order for 3,000 shares:

Merged on fee-adjusted price from (11):

A  0.340  x 1200   ->  0.340340   <- taken in full
B  0.341  x 2000   ->  0.341170   <- taken 1800 of 2000  (mu)
B  0.348  x 1500   ->  0.348174
A  0.350  x  800   ->  0.350350
A  0.360  x 2500   ->  0.360360
B  0.362  x 3000   ->  0.362181

The split beats the better single venue by $8.20 on a $1,030 order, or 79.6 basis points, and realises 17.65 basis points of slippage against the 0.340 touch. At the optimum venue A is exhausted at $\tilde{p}=0.340340$ while venue B is still filling at $\mu =0.341170$, so B is the marginal venue and condition (10) holds: no reallocation of a single share reduces cost.

Fees are taken on the margin you post, not the notional you control. Charging the notional would mean a 10x position paid ten times the fee on capital it only rented.

entry_fee    = margin x 0.01
leverage_fee = margin x 0.002 x leverage
network_fee  = $0.50            // fixed, covers gas
discount     = (entry_fee + leverage_fee) x 0.2   // PROBIO holders only

total = entry_fee + leverage_fee - discount + network_fee

The leverage component is linear: each additional 1x adds a constant 0.2% of margin, so the rate rises in a straight line rather than compounding.

Fees are charged once at entry and are not refunded when a position is closed. Closing a position returns margin plus or minus P&L.

PROBIO is the platform token, issued on Solana. The discount applies automatically to any account with a verified Solana wallet holding a non-zero PROBIO balance; there is nothing to stake or switch on. It covers the entry, leverage and parlay fees. The fixed network fee is a gas pass-through and is not discounted.

Rewards are paid out of Probio's fee revenue, so a referred trader pays exactly the same as anyone else. Nothing is earned for sign-ups alone, and nothing beyond the fourth tier.

reward_tN = fee x [0.15, 0.05, 0.025, 0.01][N - 1]   // N = 1..4 levels up
fee       = entry_fee + leverage_fee - discount   (positions)
          | parlay_fee - discount                 (parlays)

Rules

• Every account gets an invite link at /referral/join/CODE. Signed-in users can replace the generated code with their own, for example /referral/join/jack: 3 to 20 letters, numbers, - or _, changeable once every 30 days. Previous codes keep working and can never be claimed by anyone else.
• A referral is attached when a new account signs up through an invite link, or enters a code within 7 days of creating the account. It is permanent.
• Your dashboard lists the people you referred by username, or first name and last initial, with what each has generated. Second-tier accounts are counted but not named. Email addresses are never shown.
• Self-referrals and two-way referrals are rejected.
• Only fees from live-balance orders count. Demo trades earn nothing.
• Rewards accrue in USD and become payable once on-chain settlement is live.

combined_probability = p1 x p2 x ... x pn
payout_multiple      = 1 / combined_probability
payout               = stake x payout_multiple

Multiplying probabilities makes payouts climb quickly and win rates fall just as quickly. Four legs at 50% each is a 6.25% chance of paying out, at 16x.

The payout cap

Because probabilities multiply, leg count runs away quickly. Eight legs at 0.3 each imply a fair multiple above 15,000x. Quoting a number like that is not credible and the liability it creates is unbounded, so the book caps what it will pay:

The cap applies to the multiple, not to the stake, so a larger stake still scales linearly. Once it binds, the slip is priced below fair odds. The builder says so explicitly and shows the uncapped figure alongside, because a trader adding a ninth leg deserves to know it buys them nothing.

Parlays carry no leverage, so the leverage fee does not apply. The fee rate $r(M)$ rises with the payout multiple, so longer shots pay more: Under 5×: 5% · 5–20×: 7.5% · 20–100×: 10% · 100× and up: 15%. It is charged on the stake at placement, along with the fixed network fee, and the whole amount leaves the balance when the slip is placed.

Mark to market

An open slip is valued at what it pays multiplied by the probability it still lands, which keeps the mark bounded by the payout even when the cap is binding:

A parlay settles only when every leg has resolved. A single losing leg settles the whole ticket at zero.

Liquidity providers deposit USDG, USDC, USDT, ETH or SOL, valued in USD, against pool shares. The pool quotes when the external book is too thin, takes the other side of liquidations, and earns a share of trading fees in return.

shares_minted = deposit x (total_shares / pool_value)
lp_value      = shares x (pool_value / total_shares)

A market resolves when its Polymarket event resolves. Probio mirrors that result rather than running its own oracle, so there is no scenario where the two disagree on who won.

Positions still open at resolution are settled automatically. There is no action required and no expiry fee.

Example

GET /api/wallet

{
  "signedIn": true,
  "address": "0x1ee5451b4338C109aDf4c8B447fe0b700a2b9213",
  "balance": 0
}

A balance of null means the RPC could not be reached inside the timeout. The interface renders that as an em dash rather than a misleading zero, because “unknown” and “empty” are not the same claim.

Insider trading, outcome or settlement manipulation, wash trading, reward farming, exploiting platform defects and using several accounts to get around limits are prohibited. Position and per-event limits are enforced on the server when an order is accepted. The full rules, what remains allowed, how reviews work and how funds are treated are in the Market Integrity & Prohibited Trading Policy.

• Total loss. A prediction market contract settles at 1 or 0. A losing position is worth nothing, not something less.
• Leverage. At 10x a 10% adverse move erases your margin entirely.
• Liquidity. Thin books mean wide spreads and real slippage. Exiting can cost more than entering.
• Resolution. Outcomes follow the upstream oracle, including any dispute or delay in it.
• Parlays. Long tickets look cheap and are not. Combined probability falls fast.
• Custody. The derivation model documented above is a prototype construction and should not hold value you cannot afford to lose.