# LoomDesk > Protocol-owned liquidity for tokenized stocks on Robinhood Chain (chain id 4663). LOOM's trading tax builds a book of LOOM liquidity: LOOM against ETH and every tokenized stock, full-range positions in LoomDesk's own 1% pools (since 20 September 2026). Every day 80% of the USDG the book earns is paid to LOOM holders and all of the LOOM it earns is airdropped to them; LOOM is never sold. LoomDesk also runs pools of its own (Uniswap v4 pools priced by the LoomDesk fee hook against Chainlink stock feeds) and lets anyone, human or agent, provide liquidity: in its own stock pools through Earn, and in ANY pool on the chain (memecoins included) through ladders. It also indexes every swap on the chain, so an agent can see what trades, what is a trap, and what a pool really pays before it puts money in. Everything below is read-only public data unless it says otherwise. No API key. Rates are measurements of the past, never forecasts. ## MCP server - Streamable HTTP at https://loomdesk.trade/mcp, no auth. Manifest: https://loomdesk.trade/.well-known/mcp/server.json. OpenAPI for the plain endpoints: https://loomdesk.trade/openapi.json. - Client config: `{ "mcpServers": { "loomdesk": { "url": "https://loomdesk.trade/mcp" } } }`. - Nothing on our side signs, sends or holds keys. Tools that "plan" return unsigned transactions (`to`, `data`, `value` in wei, chain id 4663) that you sign and send from your own wallet, in order, each after the one before is mined. A plan is laid out from the chain at that moment and expires in twenty minutes; if the price has moved past the slippage the transaction reverts and costs only gas: ask for a new plan. - Stock pools and Earn: `list_pools`, `get_pool`, `quote_position` (sizes a position in a LoomDesk stock pool and returns the USDG approve and EarnDeskV4.open transactions), `book_status`, `my_positions`. - The whole chain and ladders: `market_tokens` (what trades, or a search, or the leaders over any window from 5 minutes to a week), `ladder_pools` (the pools of a token a ladder can go in, in the site's order), `plan_ladder`, `my_ladders`, `plan_ladder_action` (collect, close_part, close, take_nfts), `plan_open_pool`. ## Ladders: liquidity in any pool, as an agent would use it A ladder is one deposit spread over up to 40 narrow one-sided Uniswap ranges ("rungs") of one pool, v3 or v4, quoted in USDG, WETH or native ETH, or in LOOM. Rungs under the price hold the quote asset and buy the token as it falls; rungs over the price hold the token and sell it as it rises; a rung the price trades through earns the pool's swap fee. So a ladder is a grid of limit orders that is also paid fees. The loop: 1. `market_tokens` to pick a token. Prefer `tier: "established"` (two weeks of trading on most days, real depth, a sell test that keeps passing). `untested` means nobody has yet checked that a stranger can sell it. Flagged tokens are never listed. `keep` near 1 means a pool's flow is mostly ordinary traders; near 0 means mostly arbitrage, which costs liquidity more than it pays. 2. `ladder_pools` for that token. Read `paysLiquidity`: a launchpad pool whose hook keeps the whole fee pays a ladder nothing (it still fills as orders). `usdToMovePrice2Pct` is depth: keep a ladder well under it. 3. `plan_ladder` with the band in percent from the current price (`lowPct: -30, highPct: 40`), `shape` (`spot` even, `curve` heaviest near the price, `bidask` heaviest at the edges), and amounts as decimal strings. What you bring decides what is built: only the quote asset builds the half under the price, only the token the half over it. `split: true` builds the whole band from one asset: part is swapped for the other in the same pool first, in the same transaction, with the minimum out taken from the chain's quoter (a launchpad hook can tax a swap several percent; the quoter's answer already includes it). 4. Sign and send the returned transactions. Give the last one a gas limit of about 12,000,000: it mints dozens of positions. 5. `my_ladders` to watch it: value, which rungs the price has crossed, fees waiting, fees collected, and PnL against simply having held what went in. 6. `plan_ladder_action`: `collect` (fees out, ladder keeps working), `close_part` (a share of every rung out), `close`, or `take_nfts` (the position NFTs themselves, paused or not; it pays 5% of the ladder's value, see Costs). Without MCP: `POST https://loomdesk.trade/api/agent/ladder` with `{"plan": "pools" | "ladder" | "action" | "open_pool", ...}` and the same fields as the tools. Example: `{"plan":"ladder","token":"0x39dbed3a2bd333467115de45665cc57f813c4571","owner":"0xYOU","lowPct":-30,"highPct":40,"amountQuote":"50","split":true}`. Costs: 0.25% of what goes in, taken out of the rungs the moment they are minted (and of anything added to a ladder later, on top of it), paid to the book as USDG like every cut. Of it, 0.1% goes to the wallet that referred the owner (`referrer` in plan_ladder, or a ?ref=0x... link on the site; the contract keeps the first referrer for every ladder after) and 0.1% to the owner of the ladder this one copies (`copyOf`: a ladder id on the current contract, still open in the same pair). Then LoomDesk takes 5% of the trading fees a ladder earns, when they are collected, and 5% of any GAIN when liquidity is taken out (close or partial withdraw): what comes out being worth more, in the pair's money side (USDG, else ETH/WETH, else LOOM) at the pool's price, than that part of what went in. A loss pays nothing. Taking the NFTs out (`take_nfts`) closes nothing, so it pays 5% of the ladder's whole value at that moment instead, gain or loss. All are 3.5% for an owner holding at least 100,000 LOOM at that moment (the balance is read then; nothing is locked). Every cut reaches the book as USDG: it comes off the money side, a slice of the token is sold in the same pool when that is short, and ETH or LOOM is sold for USDG in the same transaction; the user bears those swaps. Of the 5%, 4.3 goes to the book and 0.7 to development. Adding: LoomLadder.add(ladderId, shareBps, max0, max1, deadline, hookData) puts shareBps more liquidity into every rung, in the shape the ladder has, paying the 0.25% on what went in; the fees waiting in the rungs are collected to the owner first (the usual 5% off), so nothing of them is folded back. LoomZap.zapAdd does it from one asset (swaps part in the ladder's own pool). What was added counts as put in. Social: a wallet can take a name and post theses (why this band, this pool, this size), on its profile and under a token; a thesis can point at one of its ladders, with a copy link. Reads: /api/social/names, /api/social/theses?token=|address=. Writes are signed messages (no transaction): see /api/social/*. Payouts: a wallet can ask, with a signature, to be paid in ETH instead of USDG (/api/social/payout); the keeper then sells its USDG share for ETH at payout time and sends it. Agent: https://loomdesk.trade/agent is the platform's own agent (Claude, with these same tools), which plans and hands the person the transactions to sign. Compounding: a ladder's owner can put its fees back into its rungs instead of claiming them (compound(ladderId, into, hookData); `into` lists rung positions in the order they are offered the money: the rung the price is inside, then the nearest over and under it). setCompound(ladderId, true) lets LoomDesk's keeper do it once a day and pay the gas; it can do nothing else with the ladder. The 5% comes off the fees first, nothing is swapped, what no rung can take goes to the owner, and what is added counts as put in, so it is not charged again as a gain. Ladders on earlier contracts do not have it. Risk, plainly: a ladder buys on the way down and sells on the way up. If the token falls through the band you hold the token, bought at falling prices; if it rises through it you have sold. Fees are the pay for that and may not cover it. Contracts were reviewed by LoomDesk and tested against live pools; they have not been audited by an outside firm. ## Opening a pool that pays If a token's only real market pays liquidity nothing, `plan_open_pool` plans a new Uniswap v4 pool for it on LoomOpenHook, against ETH or USDG, with a flat 1% or 3% fee: nine tenths to liquidity providers, one tenth to the LoomDesk book (always taken in ETH or USDG, never the token). One-off cost about a dollar (1 USDG or 0.0004 ETH); after that anyone builds in it for free. It opens at the price of the token's existing market, which the contract checks to within 2% when that market is a v4 pool in the same quote. Its trades will be mostly arbitrage (whenever the main market moves by more than the fee) plus what routers send; a new pool starts with neither. The hook has no say over adding or removing liquidity. ## Data for liquidity providers - [Pool data for agents](https://loomdesk.trade/api/agent/pools): every stock/USDG pool on the chain with depth (USDG to move the price 2%), the weekly fee rate for a dollar in a +-5/10/15/25% range, and `keep`, the share of its fees the pool's liquidity kept after arbitrage (markout at +60 min over a day). `own: true` marks LoomDesk's own pools. JSON, cached 60s. - [Market](https://loomdesk.trade/api/market): live prices and depth per stock, refreshed every 5 seconds. - [Every token on the chain](https://loomdesk.trade/api/index/tokens): the index, the 400 busiest tokens of the last day. [Search](https://loomdesk.trade/api/index/search?q=pons), [leaders over a window](https://loomdesk.trade/api/index/leaders?window=900), [one-minute-and-up OHLC candles for a pool, in dollars](https://loomdesk.trade/api/index/candles/0xf2a0be59ab76b96f957bd5e5b967f2b75e8db269?interval=15m), and a [live stream of price ticks](https://loomdesk.trade/api/index/stream) (server-sent events, about one message a second, each listing the pools that just traded). - [A wallet's ladders](https://loomdesk.trade/api/ladders?address=0x0000000000000000000000000000000000000000) and [totals](https://loomdesk.trade/api/ladders/totals). - [Earn pools](https://loomdesk.trade/api/earn/pools): the pools Earn offers, ranked, with `unit` (fee growth per unit of liquidity over sqrt(P)); divide by the range factor g = (1 - sqrt(Pa/P)) + (1 - sqrt(P/Pb)) for a return. - [The book](https://loomdesk.trade/api/live/token): LoomDesk's own positions, live. - [Payouts](https://loomdesk.trade/api/live/rewards) and [a payout's snapshot](https://loomdesk.trade/api/payouts/0): every daily epoch, its Merkle root, and the full recipient list to recompute it from. ## How the rate is computed perL = (dfg1 + dfg0 * P) / 2^128 (fee growth per unit of liquidity, priced in token1); unit = perL / sqrt(P). A position with liquidity L over [Pa, Pb] is worth L * sqrt(P) * g with g = (1 - sqrt(Pa/P)) + (1 - sqrt(P/Pb)), so a dollar in that range earns unit / g. Summed interval by interval and scaled to seven days. TVL is never used; nothing is annualised. ## Providing liquidity (on chain, needs a wallet) - Earn: https://loomdesk.trade/earn. The EarnDeskV4 contract opens a Uniswap v4 position in your wallet from USDG in one transaction: it takes USDG, buys the stock side in the pool, mints the position to you. 1% of the USDG paid in goes to the LoomDesk book, where it is paid out to LOOM holders like any other earnings. Closing is free and instant. The Earn page offers LoomDesk's own pools only (the contract itself accepts any initialised pool key). - LoomDesk pools: fee set per swap by LoomFeeHook. Ordinary flow pays the base fee (0.30%); a swap that pulls the pool toward the Chainlink price while they disagree by more than 0.6% pays the base fee plus half the gap, up to 5%; with no reference price (stale feed, weekend) a flat 1%. After each swap the hook charges a tenth of the swap fee on top of it (0.03% of a swap at the base fee, so a trade costs 0.33% in all) and sends it to the LoomDesk book; the pool's liquidity providers keep the whole fee. The hook holds no tokens and has no say over liquidity, so your position can always be withdrawn. Pools are young and shallow: keep a deposit under about a tenth of the pool's depth. ## Contracts (Robinhood Chain, 4663) - LoomFeeHook (v2, 2026-09-18): 0x60d31599D69Cd9Aa6644e6402857C5cBf7d7E0C4. The earlier hook at 0x37C86E92a081ae0c1d3aD2ea5B0bB58f56546080 took no cut; its pools are empty and retired. - LoomLadder (ladders in any pool with a money side): 0x970ADc65Ba854a9f0D8f0519959929DEbF2Bc25B (from 22 September 2026: 0.25% of what goes in to open, every cut as USDG, 5% of the value on take_nfts). Earlier LoomLadder contracts are paused for new ladders; the ladders already in them are still read, collected and closed on their own terms. Ladders are opened on this contract only. - PilotGas (the autopilot's gas tank, the LoomLadder's pilot): 0x86B5776F64fF26943724C0E5117c0b1b58d15f90. A ladder's owner sets rules (LoomLadder.setAuto: re-lay when the price leaves the rungs, take profit, stop loss, fees paid out as USDG); the keeper runs them through this contract and the gas comes out of the owner's ETH here (deposit/withdraw at will, charged at no more than a gwei a unit). No ETH in the tank, no action. - LoomZap (one asset in, a whole ladder out; no owner, no settings): 0x2911F1A4418295B14C0F908C758465a6EdA56d5d A pool quoted in WETH can be paid for in plain ETH: `plan_ladder` does it whenever the wallet holds less WETH than the amount (or with `payWithEth: true`), the zap wraps it inside the same transaction, and nothing needs approving. - LoomOpenHook (pools anyone can open): 0x49DBD99383649cB4e9a0838166cB3DE59aa960Cc - Uniswap v4 PoolManager: 0x8366a39CC670B4001A1121B8F6A443A643e40951; StateView: 0xF3334192D15450CdD385c8B70e03f9A6bD9E673b; PositionManager: 0x58daec3116aae6D93017bAAea7749052E8a04fA7 - USDG: 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168 ## Documents - [Academy](https://loomdesk.trade/academy): ladders, pools and fees in ten short lessons. - [Whitepaper](https://loomdesk.trade/whitepaper) - [Disclosures](https://loomdesk.trade/disclosures) - [Rewards](https://loomdesk.trade/rewards): how a payout happens and how to verify one. Only wallets holding at least 100,000 LOOM at the daily snapshot are paid; contracts are excluded.