Everything a trader can do is a public contract call.

import { createWalletClient, custom } from "viem";
import {
  elysiumMainnet, elystaOrderBookEngineAbi, parseWad, requireDeployment,
  Side, OrderKind, TimeInForce,
} from "@elysta/protocol";

const { contracts } = requireDeployment(99901);
const wallet = createWalletClient({ chain: elysiumMainnet, transport: custom(window.ethereum) });
const [account] = await wallet.getAddresses();

// placeOrder(PlaceOrderParams) -> orderId. Every amount is WAD (1e18); enums are uint8.
const hash = await wallet.writeContract({
  account,
  address: contracts.ElystaOrderBookEngine,
  abi: elystaOrderBookEngineAbi,
  functionName: "placeOrder",
  args: [{
    marketId: 1,                    // BTC-USD in the launch catalogue
    side: Side.Buy,                 // 0 Buy, 1 Sell
    kind: OrderKind.Limit,          // 0 Limit, 1 Market
    tif: TimeInForce.GTC,           // 0 GTC, 1 IOC, 2 FOK, 3 PostOnly
    price: parseWad("60000.0"),     // a multiple of the tick, within priceBandBps of the index
    qty: parseWad("0.01"),          // a multiple of the lot, between min and max order qty
    reduceOnly: false,
    expiresAt: 0n,                  // unix seconds; 0 means no expiry
    protectionPrice: 0n,            // market orders only
  }],
});

import { createPublicClient, http } from "viem";
import { elysiumMainnet, elystaPerpRiskEngineAbi, formatWad, requireDeployment } from "@elysta/protocol";

const client = createPublicClient({ chain: elysiumMainnet, transport: http("https://elysium-mainnet.g.alchemy.com/v2/<your-key>") });
const { contracts } = requireDeployment(99901);
const risk = { address: contracts.ElystaPerpRiskEngine, abi: elystaPerpRiskEngineAbi } as const;

// Which markets the account has a position in, then each position with the figures the terminal shows.
const marketIds = await client.readContract({ ...risk, functionName: "openMarketsOf", args: [account] });
for (const marketId of marketIds) {
  const [position, pnl, liquidationPrice, [mark]] = await Promise.all([
    client.readContract({ ...risk, functionName: "getPosition", args: [account, marketId] }),
    client.readContract({ ...risk, functionName: "unrealizedPnl", args: [account, marketId] }),
    client.readContract({ ...risk, functionName: "liquidationPrice", args: [account, marketId] }),
    client.readContract({ ...risk, functionName: "markPrice", args: [marketId] }),
  ]);
  // position.qty is signed int128: positive long, negative short. Prices and margin are WAD.
  console.log(marketId, formatWad(position.qty, 4), formatWad(position.avgEntryPrice), formatWad(position.margin),
    "pnl", formatWad(pnl), "mark", formatWad(mark), "liq", formatWad(liquidationPrice));
}

API=https://<api-host>

curl "$API/api/v1/markets"                               # every market
curl "$API/api/v1/markets/BTC-USD"                       # by symbol or id
curl "$API/api/v1/markets/BTC-USD/orderbook?levels=10"
curl "$API/api/v1/markets/BTC-USD/trades?limit=50"
curl "$API/api/v1/markets/BTC-USD/candles?interval=1h&limit=168"
curl "$API/api/v1/markets/BTC-USD/funding?limit=24"
curl "$API/api/v1/accounts/0xYourAddress"
curl "$API/api/v1/accounts/0xYourAddress/history?types=fill,funding&limit=50"
curl "$API/api/v1/protocol/status"
curl "$API/api/v1/protocol/insurance-fund"
curl "$API/api/v1/protocol/liquidations?limit=20"
curl "$API/api/v1/leaderboard?window=7d"

// wss://<api-host>/api/v1/ws
{ "op": "subscribe", "channel": "markets", "marketId": 1 }
{ "op": "subscribe", "channel": "book", "marketId": 1 }
{ "op": "subscribe", "channel": "trades", "marketId": 1 }
{ "op": "subscribe", "channel": "account", "account": "0xYourAddress" }
{ "op": "subscribe", "channel": "protocol" }
{ "op": "unsubscribe", "channel": "book", "marketId": 1 }
{ "op": "ping" }

import { createPublicClient, http, parseEventLogs } from "viem";
import { elysiumMainnet, elystaOrderBookEngineAbi, elystaPerpRiskEngineAbi, requireDeployment } from "@elysta/protocol";

const client = createPublicClient({ chain: elysiumMainnet, transport: http("https://elysium-mainnet.g.alchemy.com/v2/<your-key>") });
const deployment = requireDeployment(99901);
const { contracts, startBlock } = deployment;

// Start at the deployment's first block; nothing of Elysta's exists before it.
const logs = await client.getLogs({
  address: [contracts.ElystaCollateralVault, contracts.ElystaMarketRegistryOracle, contracts.ElystaOrderBookEngine, contracts.ElystaPerpRiskEngine],
  fromBlock: BigInt(startBlock),
  toBlock: "latest",
});

// Decode by contract. Fills carry both order ids, both fees and a sequence number shared with placements.
const fills = parseEventLogs({ abi: elystaOrderBookEngineAbi, eventName: "Fill", logs });
for (const fill of fills) {
  const { marketId, makerOrderId, takerOrderId, maker, taker, takerSide, price, qty, makerFee, takerFee, seq } = fill.args;
  // (blockNumber, logIndex) orders events across the chain; seq orders them within a market.
}
const positions = parseEventLogs({ abi: elystaPerpRiskEngineAbi, eventName: "PositionChanged", logs });