Docs

Overview

Falle is a perpetual futures exchange on Robinhood Chain. A perpetual is a position that tracks an asset's price with leverage and never expires. You put up USDG as margin, choose long or short, and your profit or loss follows the asset until you close.

You will not find an order book here, nor a market maker quoting prices. Every market reads its price from a real AMM pool on Robinhood Chain, and where Chainlink publishes a feed for the asset, that feed bounds the pool. One liquidity vault stands opposite every position. The markets are ETH, BTC, 12 tokenized US stocks and ETFs, and every coin whose pool clears the listing floor.

Current state: the contracts are written and tested but not deployed, so every position on the site today is a practice position. Prices, depth, caps and every rule below are live; the dollars are practice dollars kept by the site, not on chain.

Pricing from pools

A perp that reads one pool's spot price can be gamed: push the pool in one block, open or close at the bent price, let it snap back. Thin pools make that cheap. Falle answers with three inputs and one rule.

• Spot: the pool's current price. For ETH and BTC that is a Uniswap v3 pool read directly (ETH via 1 pool, BTC via 2 pools).
• Average: a 10-minute time-weighted average. ETH and BTC use the pool's own on-chain observations (Uniswap v3 TWAP). Stocks and coins use the site's sampled average while in practice; their on-chain version is described under Contracts.
• Chainlink: where a USD feed exists (ETH, BTC and every listed stock), its latest answer.

Worst-of fills

open long  / close short = max(spot, average, feed)
open short / close long  = min(spot, average, feed)
feed counts only while fresh (< 25 h) and within the market's bound of the pool

Opening a long or closing a short fills at the highest of the available prices; opening a short or closing a long fills at the lowest. Pushing spot up to open a long cheaper does nothing, because the average is still higher. Pushing spot up to sell a long higher does nothing either, because you exit at the lower average. To profit from manipulation an attacker has to hold the average itself off for minutes while arbitrageurs trade against them.

Pump guard and warm-up

When spot is further from the average than the market's guard (3% for majors, 4% for stocks, 8% for coins), or a coin moved more than its guard in five minutes, new positions wait. For majors and stocks, opens also wait when the pool TWAP and Chainlink differ by more than the market's bound (2% for majors, 3% for stocks), or when the Chainlink answer is older than 25 hours. A Chainlink answer counts in the worst-of fill only while it is fresh and agrees with the pool. A coin pool younger than one day does not take positions at all. Closing, adding margin and liquidating are never blocked by the guard.

Caps per side

Every market side has its own ceiling: the smaller of a slice of the vault (majors 25%, each stock 10%, each coin 4%) and a share of the pool's depth in that direction (half for majors, a quarter for stocks and coins). Long room follows what it costs to pump the pool, short room what it costs to dump it. Together they bound what a 10% bend of the price could pay out to one side: a fraction of what bending it would cost.

Profit cap

No single position can collect more than 9× its margin. When it opens, that amount is reserved inside the vault, and new positions stop once reservations reach 80% of the vault. Every winner is therefore funded before it wins.

Listing

Listing is automatic. The site scans Robinhood Chain pools against ETH, WETH and USDG, drops tokens that use a stock or major's ticker (only the official tokens carry those), and lists every coin whose deepest pool clears the floor, has not lost 90% in a day and is at least a day old. Tiers move with the pool, up or down.

Orders and execution

A market order fills at the worst-of price when it arrives, as long as that price is within the slippage you set; otherwise nothing happens. Limit orders fill once the mark reaches your price or better, stop orders once it crosses your trigger, and a scale order spreads up to ten limit orders evenly across a range. The margin of a resting order is set aside until it fills or you cancel it.

Take profit and stop loss

You can attach a take-profit and a stop-loss price when you open, or edit them on the open position. They close the full position at the worst-of exit price once the exit price crosses them.

Funding

Funding is a straight line of the open-interest skew, limited to ± the cap:

rate per day = cap × clamp((long OI − short OI) ÷ skew scale, −1, 1)
owed         = notional × rate per day × days held   (positive: longs pay shorts)

Positive means longs pay shorts. The caps are 0.30% a day for majors, 0.30% for stocks and 1% for coins. The skew scale is fixed per market in the engine ($2M for ETH and BTC, $500K for each stock); for practice coin markets it is twice the sum of both side caps. Funding accrues continuously on notional and settles when the position closes.

Margin and leverage

Positions are isolated: each has its own margin, its own liquidation price and its own profit cap. The open fee is charged on top of your margin (taker 6 bps on majors, 10 on stocks, 15 on coins); the close fee comes out of the position's equity. You can add margin to an open position to move its liquidation price away. Cross-margin across positions is not offered: a shared margin pool would let a loss in a thin coin pull down a healthy ETH position, and that needs a portfolio risk engine the first contracts do not have.

Liquidation

liquidatable when  margin + PnL(average) − funding  <  maintenance × size × average
liquidator earns   min(margin, liquidation fee × size × average)

A position can be liquidated when its equity (margin + PnL − funding − the close fee) falls below maintenance × notional at the mark. The mark is the average price, not spot, so a single wick does not liquidate anyone. The test is margin + PnL − funding against maintenance × notional; the close fee is not part of it. Anyone may liquidate an eligible position on chain and earns the liquidation fee (0.5% of size on majors, 1% on stocks), capped at the margin; the rest of the margin goes to the vault. A loss larger than the margin is not owed by the trader and is not a debt of the vault: the vault simply receives less than it would have.

Stock sessions

The stock feeds on Robinhood Chain follow the 24/5 US equity session: Sunday 20:00 to Friday 20:00 New York time. A stock position opens only while its Chainlink answer is less than 25 hours old and agrees with the pool, so opens pause through most of the weekend once the feeds go quiet; closes, margin and liquidations work at any time. Weekend gaps are real: a stock can open on Monday far from Friday's close. Stock tokens are identified on chain by Robinhood's token beacon, never by ticker, because many tokens borrow stock tickers.

The vault

Liquidity providers deposit USDG and receive vault shares. The share price follows NAV: USDG held minus what open positions are net owed (only traders' unrealised gains are subtracted, losses are not counted until realised). All trading fees and funding paid to the vault accrue to shares. Withdrawals are queued, wait a one-hour cooldown, then can be redeemed during a 48-hour window, and a redemption is refused while it would leave reservations above 80% of the vault. The first deposit is protected against share-price inflation by a fixed virtual offset.

$FALLE

$FALLE is the Falle token on Robinhood Chain. It has not launched; its address will appear on the token page and on the home page. Holder perks (fee rebates, a points boost) are plans that start with the deployed contracts. The perpetual contracts do not depend on $FALLE and can go live before it.

Parameters

Live per-market parameters (leverage, maintenance, fees, depth, caps, funding) are on the markets page and in each market's panel in the terminal. Settlement token: USDG 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168 (6 decimals).

Risks

• Leverage can lose your entire margin quickly. At 20×, a 5% move against you is enough.
• Pool prices can be pushed. The rules here make it costly, not impossible, and a coin can gap, lose its pool or be abandoned.
• USDG is treated as one dollar. A loss of its peg would change every balance.
• Chainlink feeds can pause or lag; stock feeds stop over weekends and markets can open with a gap.
• Official stock tokens are issued by Robinhood with a blocklist, a pause and admin burn functions. The engine never holds them (positions are synthetic), but their pools could be affected.
• The contracts are written without an admin key, pause or upgrade path. That protects deposits from an operator, and it also means a bug could not be patched in place.
• Practice results say nothing about real trading. Fills on chain also pay gas and can face network congestion.

Contracts

Two contracts, both without owner, admin, pause, fee setter or proxy. Every parameter is fixed in the constructor. The vault is bound to the engine once, by the deployer, in a call that locks itself.

FalleVault

• constructor(usdg) fixes the settlement token; the deploying address is stored as the only one that may bind the engine.
• bindEngine(engine) one call, deployer only, then locked forever.
• deposit(assets, receiver, minShares) pulls USDG (balance-difference checked) and mints shares at NAV, with a virtual offset against first-deposit inflation.
• requestWithdraw(shares) locks the shares in the vault and starts the one-hour cooldown.
• withdraw(minAssets) inside the 48-hour window, pays shares × NAV ÷ supply if reservations stay within 80% of what remains.
• cancelWithdraw() returns queued shares.
• nav(), liability(), reserved(), previewDeposit, previewRedeem, maxRedeemableAssets, requests(account) views.

FalleEngine

• constructor(vault, markets[]) up to 32 markets, each checked on chain: pools, TWAP readability, feed decimals, leverage against maintenance.
• open(marketId, isLong, margin, leverage, acceptablePrice, deadline) pulls margin plus fee, fills at the worst-of price, reserves 9× margin in the vault.
• close(id, acceptablePrice, deadline) settles PnL, funding and the close fee against the vault; payout capped at margin + reserve.
• addMargin(id, amount) moves the liquidation price away.
• liquidate(id) anyone, once margin + PnL − funding is under maintenance at the TWAP; pays min(margin, notional × fee).
• marketState(id), prices(id), quoteOpen, quoteClose, position(id), positionsOf(owner), depthUsd(id), tierLeverage(depth) views the terminal reads.

Coin markets on chain

Most coins trade in Uniswap v4 pools, which keep no price history of their own. Putting coin markets on chain needs a recorder that stores time-weighted observations of those pools, written by anyone and bounded so a single update cannot move the average far, plus listing checks the contract can verify itself (pool age, depth, deviation). That is designed but not part of the first deployment; until then coin markets stay in practice mode.

Anyone can confirm that a deployed address runs exactly this code with npm run verify-deployment, which compares bytecode and every constructor argument against the build.

FAQ