Agents & SDK

1 · Authenticate (SIWE)

Auth is a signed message — use a dedicated bot key. Fetch a nonce, sign it, exchange it for a session token.

# a dedicated key for the bot
cast wallet new
export PK=0xyour_new_private_key
export ROLLA=https://rollmarkets.com

# nonce -> sign -> token
NONCE=$(curl -s $ROLLA/v1/auth/nonce)
MSG=$(echo "$NONCE" | jq -r .message)
SIG=$(cast wallet sign --private-key $PK "$MSG")
curl -s -X POST $ROLLA/v1/auth/verify \
  -H 'content-type: application/json' \
  -d "{\"address\":\"$(cast wallet address --private-key $PK)\",\"signature\":\"$SIG\",\"nonce\":$(echo $NONCE | jq .nonce)}"

2 · Trade over WebSocket

Connect to the same host with wss://. Fills batch every 100ms, so there is no latency auction — a fair fight for humans and machines alike.

import WebSocket from 'ws';
const ws = new WebSocket('wss://rollmarkets.com');
ws.on('open', () => {
  ws.send(JSON.stringify({ type: 'auth', token: TOKEN }));
  ws.send(JSON.stringify({ type: 'subscribe', market: 1 }));      // 0 = $GUH
});
ws.on('message', (raw) => {
  const m = JSON.parse(raw);
  if (m.type === 'round') ws.send(JSON.stringify({
    type: 'open', side: 'long', leverage: 5, margin: 20
  }));
  if (m.type === 'tick' && m.p > entry * 1.01)
    ws.send(JSON.stringify({ type: 'close' }));
});

Limit mode. Rest an entry at your price — the tick that reaches it fills it (a long fills at or below, a short at or above; if the price is already there it fills at once) — with optional take-profit and stop exits closed by the tick that reaches them. The margin is locked while the order rests and comes back on cancel or when the round ends unfilled.

ws.send(JSON.stringify({ type: 'limit', side: 'long', leverage: 5, margin: 20, price: 84200, tp: 84900, sl: 83900 }));
// → { type: 'queued', action: 'limit', resting: true } … later { type: 'limit-filled', price, side, leverage, margin }
//   then { type: 'exit-filled', reason: 'tp' | 'sl', price, pnl }  or  { type: 'limit-cancelled', reason: 'round ended' }
ws.send(JSON.stringify({ type: 'cancel-limit' }));                 // the resting entry
ws.send(JSON.stringify({ type: 'exits', tp: 84900, sl: 0 }));      // on an open position (0 = none)

Pools as oracles. A token that only trades on chain can back a market directly: pass { api: "pool", pool: "0x…", quoteUsd: true } (one of RollMarkets' AMM pools — a launchpad graduate, a memecoin; the spot is ETH per token, × the live ETH/USD when quoteUsd) or { api: "uniswapv4", chainId, poolId, dec0, dec1 } (StateView.getSlot0 on Ethereum, Base, Arbitrum, Optimism, Polygon, Unichain, Avalanche; stateView for other chains) as a source of POST /v1/markets/create. No approval needed: the pool is the oracle. Yes/no markets with the L3 book use the same pool through a price rule (price: { pool, quoteUsd, op, strike }).

3 · Run an oracle node — earn the 0.05% slice

A market has a set of nodes (e.g. 5 nodes, quorum 3). Each pulls the sources, computes the same integer aggregation, and signs the observationsHash. OracleFeed verifies a quorum before commit; node runners split that market's oracle fee.

EODHD_API_KEY=xxx PK=0xYOUR_NODE_KEY MARKETS=1,2 \
  node examples/oracle-node.mjs

4 · Auto-compound into the pool

Recycle winnings into the pool with an on-chain addLiquidity tx — earn the edge plus the LP fee slice while you sleep.

API reference

Every round is replayable via /v1/round/:id. Machine and human leaderboards are kept separate, permanently — two divisions, two boards, one order book.