CoreBook Developer Docs

import { humanPriceToWei, weiPriceToHuman, snapToTick, snapToLot, computeQuote } from '@aere/sdk';

// "0.85 quote per base" → uint128 book price (P × 1e18, regardless of decimals)
const raw   = humanPriceToWei('0.85', 6 /* quote decimals */, 18 /* base decimals */);
const price = snapToTick(raw, m.priceTick);          // snap to the market's grid

// 1,000 whole base units, snapped to the lot grid
const qty = snapToLot(1000n * m.baseDecimalsFactor, m.lotSize);

// exact mirror of the contract's fill math (floor division)
const quoteOut = computeQuote(price, qty, m.quoteDecimalsFactor, m.baseDecimalsFactor);

weiPriceToHuman(price);  // → "0.85"

npm i @aere/sdk

import { CoreBookClient, AERE_COREBOOK } from '@aere/sdk';

const book = new CoreBookClient({
  address: AERE_COREBOOK.markets['WAERE/USDC.e'], // empty until launch — any book address works
  provider: window.ethereum,                        // any EIP-1193 provider on chain 2800
});

const m = await book.marketInfo();
// { base, quote, sink, priceTick, lotSize, takerFeeBps,
//   quoteDecimalsFactor, baseDecimalsFactor }

import { COREBOOK_BID_EMPTY, COREBOOK_ASK_EMPTY, weiPriceToHuman } from '@aere/sdk';

const [bid, ask] = await Promise.all([book.bestBid(), book.bestAsk()]);

// sentinels: bid side empty → 0n; ask side empty → 2**128 - 1
if (bid !== COREBOOK_BID_EMPTY) console.log('best bid', weiPriceToHuman(bid));
if (ask !== COREBOOK_ASK_EMPTY) console.log('best ask', weiPriceToHuman(ask));

import { humanPriceToWei, snapToTick, snapToLot, computeMaxBuyLock } from '@aere/sdk';

const [from] = await window.ethereum.request({ method: 'eth_requestAccounts', params: [] });

// 1 — build a tick/lot-legal order
const price = snapToTick(humanPriceToWei('0.85', 6, 18), m.priceTick);
const qty   = snapToLot(1000n * m.baseDecimalsFactor, m.lotSize);

// 2 — approve the exact BUY lock: principal + fee ceiling + 256-wei buffer.
//     (For SELL orders, approve the base quantity instead.)
const lock = computeMaxBuyLock(price, qty, m.takerFeeBps, m.quoteDecimalsFactor, m.baseDecimalsFactor);
await book.ensureApprovalForBook(m.quote, from, lock); // approves only if needed

// 3 — rest on the book. Reverts with CrossingRequiresSlippage if it would
//     match immediately — crossing flow belongs to placeIOC / placeWithSlippage.
const txHash = await book.placeGTC(from, 0 /* BUY */, price, qty);

// optional: custom anti-spoof cancel delay (0–1200 blocks; default is 2)
await book.placeGTC(from, 0, price, qty, 10);

// Sweep the ask side up to a worst price. Unfilled remainder is discarded.
await book.placeIOC(from, 0 /* BUY */, worstPrice, qty);

// Recommended for anything size-sensitive: explicit bounds, atomic revert.
await book.placeWithSlippage(
  from, 0 /* BUY */, price, qty, 1 /* IOC */,
  minBaseFilled,        // revert if fewer base units fill
  maxQuoteSpent,        // hard cap on quote out — (1n << 256n) - 1n = uncapped
  maxAvgPriceWei,       // average-price band — 0n disables
);

await book.cancel(from, orderId);          // honors the order's cancel delay

// pull-based credits exist only if a direct payout transfer ever failed
const { base, quote } = await book.claimableOf(from);
if (base  > 0n) await book.claimBase(from);
if (quote > 0n) await book.claimQuote(from);

// anyone may forward accrued taker fees to AereSink
await book.flushFees(from);

const { bids, asks } = await book.depth(15);
// bids: best (highest) first · asks: best (lowest) first
// each level: { price, quantity, orderCount, truncated }

// orderId = uint128(keccak256(abi.encode(maker, nonce))) — derived client-side.
// openOrdersOf probes recent nonces until openOrderCount orders are found.
const open = await book.openOrdersOf(from);
// [{ orderId, maker, side, price, quantity, placedAt, cancelDelayBlocks, … }]

// or derive ids yourself (a maker's first order uses nonce 1):
import { deriveOrderId } from '@aere/sdk';
const nonce  = await book.makerNonce(from);   // latest used nonce
const lastId = deriveOrderId(from, nonce);
const order  = await book.getOrder(lastId);   // { exists, price, quantity, … }

await book.pendingSinkFee();        // taker fees waiting for the next flush
await book.openOrderCount(maker);   // resting orders (max 256 per maker)
await book.balanceOf(m.quote, from);// ERC-20 funding check before placing
await book.allowanceForBook(m.quote, from);

import { decodeCoreBookLogs } from '@aere/sdk';

const receipt = await window.ethereum.request({
  method: 'eth_getTransactionReceipt', params: [txHash],
});
const events = decodeCoreBookLogs(receipt.logs, book.address);

for (const ev of events) {
  if (ev.type === 'Filled') console.log(`filled ${ev.quantity} @ ${ev.price}`);
}

import { TOPIC_ORDER_PLACED, TOPIC_FILLED, TOPIC_ORDER_CANCELLED, decodeCoreBookLogs } from '@aere/sdk';

const logs = await provider.request({
  method: 'eth_getLogs',
  params: [{
    address: book.address,
    topics: [[TOPIC_ORDER_PLACED, TOPIC_FILLED, TOPIC_ORDER_CANCELLED]], // OR-match
    fromBlock: lastSeen, toBlock: 'latest',
  }],
});
const events = decodeCoreBookLogs(logs);

// wss://wss.aere.network — sub-second blocks make polling fine too,
// but eth_subscribe gives you fills the moment they land.
ws.send(JSON.stringify({
  jsonrpc: '2.0', id: 1, method: 'eth_subscribe',
  params: ['logs', { address: book.address, topics: [[TOPIC_FILLED]] }],
}));
// decode incoming params.result with decodeCoreBookLogs([log])