Order history

GET /orders lists the orders submitted through POST /order/openfor: every lane except the open flow. Each entry joins what was asked (the quote) with what the hub has seen on chain.

Paging

for await (const page of client.walkOrders()) {
  for (const entry of page) render(await client.summarizeOrder(entry));
}

// or everything at once (newest first with sortOrdersNewestFirst):
const all = await client.listAllOrders({ maxPages: 5 });

walkOrders follows the guide’s cursor rule: the last entry’s submittedAt is the next since. It removes duplicates by orderId and stops on a short page, on a page that added nothing, or after maxPages (default 20). pageSize defaults to the hub’s maximum, 500. What the list holds depends on the transport:

On your server, with your key (hubTransport), it is the history of the transport’s one subject (default unless you set another): every order made under it, whichever of your users placed it. Never hand it to a browser unfiltered. With a user’s subject (client.walkOrders({ subject }), or a client made with createInteropClient({ transport, subject })), it is only that user’s orders (Authentication — your users).
Through your proxy (proxyTransport), it is already the signed-in user’s own orders: the proxy scopes it to the user, by the user’s subject or from your organization’s listing (Partner backend).
With a project id (projectTransport), the history is not open: keep the ids of the orders the page submits (the submitted event), and follow them with trackOrder.

A readable row

summarizeOrder(entry) resolves assets through the catalog and returns an OrderSummary:

Field	Meaning
`phase`	`submitted`, `open`, `filling`, `filled`, `settled`, `refunded` or `expired`, from the chain facts
`pay`	what the user paid: `symbol`, `decimals`, `amount` (base units), `isCeiling` (token-in), `paidInNative`
`receive`	what the recipient gets: the quoted `amount`, and `paidAmount` once a fill is seen; `recipient`
`orderId`, `hubOrderId`, `onchainOrderId`, `quoteId`	the order’s ids
`submittedAt`	when it was submitted
`openTxHash`, `fillTxHashes`	the escrow’s open, and the fills
`refundEstimate`, `refundableAfter`	the hub’s advisory refund estimate and the deadline in force

import { formatUnits } from "@c8ntinuum/infinity-interop-sdk";

const row = await client.summarizeOrder(entry);
const paid = row.pay.decimals === undefined ? `${row.pay.amount} (base units)` : formatUnits(row.pay.amount ?? 0n, row.pay.decimals);
console.log(`${row.phase}: ${paid} ${row.pay.symbol}`);

decimals is known for catalog assets and for legs the hub joined; it is never guessed. A token the catalog does not list (a launchpad token by address) may come back without it.

expired means the fill deadline passed, which comes before refunds open. An expired order is not yet refundable: see Refunds.

Following one order

Call	Returns
`client.trackOrder(orderId, { onchainOrderId })`	waits until the order ends, by the chain facts and the aggregator’s state. See Tracking
`client.waitForOrder(orderId)`	waits on the aggregator’s state only
`client.api.getOrderStatus(orderId)`	one read of the aggregator’s (advisory) status, by `orderId` or `hubOrderId`
`client.api.getOnchainFill(onchainOrderId)`	one read of the chain facts: open, filled, settled, refunded, with the observers’ watermarks
`client.findOrderByTx(chainDomain, txHash)`	which order a settler transaction belongs to: after a lost answer, from a transaction hash

On a server that names your users, pass the order’s subject to trackOrder, waitForOrder and getOrderStatus too: the aggregator’s status view reads it. The chain facts and the open flow’s lifecycle view do not.

Open-flow orders

Open-flow orders (POST /order) are not listed in GET /orders. Keep their ids when you submit them, and follow them on the hub’s lifecycle view with waitForHubOrder (or executeQuote, which does it for you).

Get started

Core concepts

Resources

API reference

SDK

SDK reference

Paging

A readable row

Following one order

Open-flow orders

​Paging

​A readable row

​Following one order

​Open-flow orders

Paging

A readable row

Following one order

Open-flow orders