Ondo Global Markets

Ondo Global Markets brings tokenized stocks & ETFs on-chain as DeFi strategies (protocol: "Ondo", network: bsc). The market-share position always lives on BSC, but clients can fund a buy from — or receive a sell payout on — another EVM chain. Pods handles the bridge and the async order fill.

Overview

Item	Value
Strategy ID format	`Ondo-<TICKER>-bsc` (e.g. `Ondo-AAPL-bsc`)
Position chain	BSC (`56`)
Strategy asset	Market-share token on BSC (symbol ends in `ON`, e.g. `AAPLON`)
Underlying reference	USDC on the funding/payout chain (decimals vary by chain — see §8)
Buy / Sell actions	`request-lend` (buy) / `request-withdraw` (sell)
Minimum buy	`$10` USDC (`strategy.metadata.minRequestLendUsd`)
Auth	Header `x-api-key: <your-key>`

Flow summary

Same-chain (BSC):
  Buy:  USDC (BSC)          → [client signs on BSC] → market shares (BSC)
  Sell: market share (BSC)  → [client signs on BSC] → USDC (BSC)

Crosschain:
  Buy:  USDC (origin)      → [client signs on origin chain] → market shares (BSC)
  Sell: market share (BSC) → [client signs on BSC]          → USDC (destination chain)

Position: always queried with the wallet on BSC

Settlement is asynchronous. The on-chain transaction submits the request in seconds; the order reaches SUCCESS only after Ondo fills it (minutes later). For crosschain, the bridge leg settles first, then the order. Track both the on-chain receipt and the action status via WebSocket or history polling.

Quote and bytecode come from the same call. GET /strategies/:id/bytecode returns a priced quote (for your UI) and bytecode[] (to execute on-chain).

Authentication

Every request requires:

x-api-key: <your-api-key>

The key identifies your customer. Fee configuration and strategy catalog are scoped to it.
Success responses are the bare JSON body (HTTP 200). Errors use { "error": { "code", "message", "details?" } }.
Keep the API key on your backend — never expose it in a browser app.

Integration flow

BUY (request-lend)                          SELL (request-withdraw)
──────────────────                          ───────────────────────
1. GET /ondo/stocks/market-status           (same)
2. GET /tokens?category=stock&chainId=56    (same)
3. GET /v2/strategies?protocol=Ondo&network=bsc  → strategyId
4. GET /strategies/:strategyId/bytecode
     action=request-lend                      action=request-withdraw
     amount=<fundingBaseUnits>                 amountInShares=<shareWei>
     fromChainId / fromTokenAddress            toChainId / toTokenAddress
5. Show quote; validate $10 minimum (buy)    (same)
6. Execute bytecode[] on the correct chain    (same)
7. Track action status until SUCCESS          (same)
   (WebSocket, GET /strategies/:id/status, or position/history polling)
8. Refresh positions                          (same)

1. Market status

Gate buy/sell when the market is closed.

GET /ondo/stocks/market-status

Key field: isOpen — block new submissions when false. The payload may also include session details (marketStatus, nextOpen, nextClose). Per-asset eligibility during off-hours can still fail at quote time with errors such as COW_ASSET_SESSION_CLOSED — see Ondo GM docs.

2. List Stocks & ETFs

GET /tokens?category=stock&chainId=56&limit=300

GET /tokens requires the wallet product type on your API key (customer.productType must include wallet). Keys with API-only scope receive 403 Forbidden. Workaround: list Ondo strategies via GET /v2/strategies?protocol=Ondo&network=bsc — each strategy includes assetToken (market-share symbol, address, decimals).

category accepts comma-separated values (stock, etf).
Each token: { symbol, name, address, decimals, chainId, category, priceInUSD, logoURI? }.
Ondo symbols end in ON (e.g. AAPLON). Strip ON for display if desired.

3. Resolve strategy ID

A market-share token address alone is not enough — you need the strategy id.

GET /v2/strategies?protocol=Ondo&network=bsc

Returns { data: [...], pagination }. Pick the strategy where:

asset matches the market-share token address
networkId === 56

Use actions request-lend (buy) and request-withdraw (sell) from availableActions.

4. Buy — `request-lend`

GET /strategies/:strategyId/bytecode

Parameter	Required	Description
`action`	yes	`request-lend`
`wallet`	yes	Address that signs on the funding chain
`amount`	yes	Funding token in base units on `fromChainId`. Use the token’s decimals (from `fromTokenAddress`), not a fixed 6 — e.g. `10000000` = $10 USDC on Base (6 dec); `10000000000000000000` =$ 10 USDC on BSC (18 dec). Read `quote.tokenIn.decimals` to confirm.
`fromChainId`	yes	Funding chain (`56` for same-chain BSC, or another supported chain)
`fromTokenAddress`	yes	USDC (or supported token) contract on `fromChainId`. Required whenever `fromChainId` is set.

Same-chain (BSC): fromChainId=56, fromTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d (18 decimals). The client signs on BSC. Crosschain: fromChainId= origin chain (e.g. 8453 Base). The client signs only on the origin chain; Pods bridges funds to BSC and fills the order asynchronously. Response (relevant fields):

{
  "id": "<actionId>",              // correlate status & WebSocket
  "chainIdIn": 8453,               // funding chain (where the client signs)
  "chainIdOut": 56,                // position chain (BSC)
  "crossChain": { "isCrossChain": true, "chainIdIn": 8453, "chainIdOut": 56 },
  "singleUseAddress": "0x…",       // SUW that executes the CoW order
  "orderUid": "0x…",               // CoW order id
  "quote": {
    "tokenIn":  { "amount", "amountInUSD", "symbol", "decimals", ... },
    "tokenOut": { "amount", "minAmountOut", "amountInUSD", ... },
    "feeBreakdown": { "summary": { "platformFeesTotalInUSD", "bridgeAndSlippageImpactOutUSD" } }
  },
  "bytecode": [
    { "to": "0x…", "value": "0", "data": "0x…", "chainId": "8453" }
  ]
}

Client execution

Atomic execution is mandatory. Cross-chain buys may return multiple legs on the funding chain (approve + bridge). Execute every leg where chainId === chainIdIn in one transaction — never as separate sends. Partial execution parks funds in escrow with PENDING status and no pipeline progress. See Executing Bytecode and EIP-7702.

Filter bytecode where chainId === chainIdIn (same-chain: 56; crosschain: the origin chain).
Batch all filtered legs into one signed transaction (output=bytecode + EIP-7702, or output=userOperation / output=fireblocks per your wallet stack).
Wait for async completion (crosschain: bridge → BSC → CoW order fill).

Minimum: $10 USDC (enforced server-side, error REQUEST_LEND_AMOUNT_TOO_LOW). For crosschain the minimum is checked on the bridged USDC amount that lands on BSC.
Use quote for pricing UI; use quote.feeBreakdown.summary for fee display.

Crosschain: the client only signs on the origin chain. Bridge + market-share purchase are handled by Pods.

5. Sell — `request-withdraw`

GET /strategies/:strategyId/bytecode

Parameter	Required	Description
`action`	yes	`request-withdraw`
`wallet`	yes	Address on BSC (where market shares are held)
`amountInShares`	yes	Share amount in wei (18 decimals)
`toChainId`	yes	Payout chain (`56` for same-chain BSC, or another supported chain)
`toTokenAddress`	yes	USDC (or supported token) on `toChainId`. Required whenever `toChainId` is set.

Same-chain (BSC): toChainId=56, toTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d. The client signs on BSC.

Use amountInShares (not amount) for Ondo sells. No minimum sell amount.
Response shape matches buy (id, chainIdIn, chainIdOut, crossChain, singleUseAddress, orderUid, quote, bytecode).

Crosschain: toChainId= destination chain. The client signs only on BSC (shares live there); Pods sells the market share for USDC on BSC, then bridges the proceeds to the destination chain. Client execution

Batch all BSC legs (chainId === 56) into one atomic transaction. See Executing Bytecode.

Filter bytecode where chainId === 56 (always BSC — shares are on BSC).
Batch and sign on BSC in a single transaction.
Wait for async completion (CoW order fill → crosschain: bridge USDC to toChainId).

Crosschain: the client only signs on BSC. Market share → USDC redemption and the bridge payout are async.

6. Positions & pending requests

The wallet is always normalized to BSC (same EVM address regardless of funding/payout chain).

Wallet snapshot (all positions)

GET /v2/wallets/:address?include=all

Stocks & ETFs appear under earn.positions where strategy.protocol === "Ondo".

Single strategy position

GET /v2/wallets/:address/strategies/:strategyId

GET /v2/strategies/:strategyId?wallet=<address>&fromActions=1

Use fromActions=1 for correct accounting (principal, profit, in-flight operations).

Position shape

{
  "spotPosition": {
    "currentPositionInShares": {
      "value": "<raw>",
      "decimals": 18,
      "symbol": "AAPLON",
    },
    "underlyingBalanceUSD": 14.98,
    "requestedToLend": [],              // pending buy, USDC
    "requestedToLendInShares": [],      // pending buy, shares
    "requestedToWithdraw": [],          // pending sell, USDC
    "requestedToWithdrawInShares": [],  // pending sell, shares
    "profitInUSD": 0.12,
  },
  "strategy": {
    "protocol": "Ondo",
    "id": "Ondo-AAPL-bsc",
    "asset": "0x…",
    "networkId": 56,
    "metadata": { "ondoSymbol": "AAPL", "minRequestLendUsd": 10 },
  },
}

`requestedTo*` fields

These arrays represent pending async orders not yet settled (same on same-chain and crosschain):

Field	Meaning
`requestedToLend`	USDC committed to a pending buy
`requestedToLendInShares`	Equivalent shares for pending buy
`requestedToWithdraw`	USDC value of a pending sell
`requestedToWithdrawInShares`	Shares committed to a pending sell

Empty arrays mean nothing is pending. Expected states

Buy submitted, shares not yet credited → requestedToLend / requestedToLendInShares populated.
Sell submitted, USDC not yet paid out → requestedToWithdraw / requestedToWithdrawInShares populated.
Settled → all pending arrays empty; currentPositionInShares / underlyingBalanceUSD reflect the real balance.

Suggested polling: every 5–15 s until the pending arrays clear (or use WebSocket/webhook below).

Available balance for sell

availableShares = currentPositionInShares.value − Σ requestedToWithdrawInShares
availableUSD    = underlyingBalanceUSD − Σ requestedToWithdraw   (clamp ≥ 0)

Do not subtract pending buys from available shares. Use availableShares as amountInShares when selling the full position.

7. Track order status

After submitting bytecode[] on-chain, the action is not complete until status is SUCCESS.

HTTP — pending actions for one strategy

Poll when you want a strategy-scoped snapshot without loading the full wallet or strategy position. The handler refreshes in-flight operations before responding.

GET /strategies/:strategyId/status?wallet=<address>

Parameter	Required	Description
`strategyId`	yes (path)	Strategy slug or id (e.g. `Ondo-AAPL-bsc`)
`wallet`	yes	Same wallet used in the bytecode call

What appears in `actions[]`

Action state	Listed?	Where to track instead
`PENDING`	yes	This endpoint
`INITIAL` (user has not sent the funding tx yet)	no	`GET /actions/:id`, WebSocket
`SUCCESS`, `REFUNDED`, `FAILED`, etc.	no	History, wallet position, WebSocket

Root response (always)

{
  "strategyId": "Ondo-AAPL-bsc",
  "wallet": "0x49A54d4d925868475Eb8d2cb2c784481ca755e8A",
  "hasPending": true,
  "message": "1 pending action(s) for this strategy.",
  "actions": []
}

Field	Type	Description
`strategyId`	string	Strategy slug
`wallet`	string	Checksummed address from query
`hasPending`	boolean	`true` when `actions.length > 0`
`message`	string	Human-readable summary
`actions`	array	Pending actions only (see below)

Ondo Global Markets strategies only — root also includes orderBook:

"orderBook": {
  "requestLend": {
    "canOpenOrder": true,
    "code": null,
    "errorType": null,
    "message": null,
    "retryable": false,
    "probeSellAmount": "100000000000000000000",
    "probeBuyAmount": "…"
  },
  "requestWithdraw": { /* same shape when sell is supported */ }
}

`orderBook` field	Meaning
`canOpenOrder`	Whether a new buy/sell request is likely to succeed right now
`code`	Stable error code when `canOpenOrder` is `false`
`errorType`	Additional machine-readable reason (nullable)
`message`	Human-readable reason (nullable)
`retryable`	Client may retry later (e.g. market closed)
`probeSellAmount`	Amount used for the availability probe (raw units)
`probeBuyAmount`	Expected output from probe when `canOpenOrder` is `true` (optional)

Present even when actions is empty.

Each item in `actions[]`

Base fields (every pending action)

{
  "id": "674a1b2c3d4e5f6789012345",
  "type": "SAMECHAIN_INVESTMENT_DEPOSIT",
  "status": "PENDING",
  "createdAt": "2026-05-29T12:00:00.000Z",
  "updatedAt": "2026-05-29T12:10:00.000Z",
  "currentStep": {
    "stepIndex": 2,
    "status": "PENDING",
    "legs": [{ "kind": "SWAP", "status": "PENDING", "operator": null }]
  },
  "steps": [
    { "stepIndex": 0, "status": "SUCCESS", "legs": [] }
  ]
}

Field	Notes
`type`	Buy: `SAMECHAIN_INVESTMENT_DEPOSIT` or `CROSSCHAIN_INVESTMENT_DEPOSIT`. Sell: `SAMECHAIN_INVESTMENT_WITHDRAW` or `CROSSCHAIN_INVESTMENT_WITHDRAW`
`currentStep`	First step still `INITIAL` or `PENDING`; `null` if none
`steps`	Full pipeline snapshot
`steps[].legs[]`	`{ kind, status, operator }` — leg kind examples: `SWAP`, `PRESIGN`, `TRANSFER`, `BRIDGE`

Cross-chain pending actions include only the base block (no suw). suw block (Ondo Global Markets request-lend / request-withdraw only)

"suw": {
  "singleUseAddress": "0x…",
  "phase": "order_in_progress",
  "fundsReturnedToWallet": false,
  "order": {
    "orderUid": "0x…",
    "posted": true,
    "quoteId": "…",
    "action": "request-lend",
    "sellAmount": "10000000000000000000",
    "buyAmount": "…",
    "status": "open",
    "validTo": 1710000000,
    "creationDate": "…",
    "executionDate": null,
    "executedSellAmount": null,
    "executedBuyAmount": null,
    "txHash": null
  },
  "balances": {
    "underlying": {
      "address": "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
      "symbol": "USDC",
      "decimals": 18,
      "amountRaw": "10000000000000000000",
      "amountHumanized": "10.0"
    },
    "strategy": {
      "address": "0x…",
      "symbol": "AAPLON",
      "decimals": 18,
      "amountRaw": "0",
      "amountHumanized": "0.0"
    }
  },
  "timing": {
    "requestedAt": "2026-05-29T12:00:00.000Z",
    "ageSeconds": 1800,
    "deadlineSeconds": 7200,
    "refundAt": "2026-05-29T14:00:00.000Z",
    "secondsUntilRefund": 120
  },
  "pricing": {
    "side": "BUY",
    "referencePriceUsd": 200,
    "livePriceUsd": 214,
    "priceSource": "ondo",
    "driftBps": 700,
    "slippageBps": 100
  },
  "suwSteps": [
    {
      "stepIndex": 1,
      "label": "presign",
      "status": "SUCCESS",
      "txHash": "0x…",
      "legs": []
    }
  ]
}

`suw` field	Meaning
`singleUseAddress`	Ephemeral wallet executing the async settlement
`phase`	High-level lifecycle — see table below
`fundsReturnedToWallet`	Final transfer to the user wallet completed
`order`	Settlement order metadata; `null` if not created yet
`balances`	Tokens on the single-use wallet during settlement; `null` after funds returned
`timing`	Request age, SLA, refund countdown
`pricing`	Reference vs live market price; `null` if unavailable
`suwSteps`	Internal settlement substeps (`presign`, `swap_and_settlement`, `forward_to_wallet`)

`suw.phase` lifecycle

Phase	UI meaning
`awaiting_transfer`	User has not completed the funding transfer
`awaiting_presign`	Funds received; Pods preparing settlement
`order_in_progress`	Settlement order open, awaiting fill
`awaiting_forward`	Fill complete; final transfer to user wallet pending
`completed`	Fully settled
`refunded` / `expired` / `failed` / `cancelled`	Terminal — drops out of `actions[]` on next poll

`suw.order` shapes

Not posted yet (posted: false):

{
  "orderUid": "0x…",
  "posted": false,
  "quoteId": "…",
  "action": "request-lend",
  "sellAmount": "…",
  "buyAmount": "…",
  "status": "not_posted",
  "lastPostError": null,
  "lastPostAttemptAt": null,
  "canOpenOrder": true,
  "code": null,
  "message": null,
  "retryable": true
}

Posted / live (posted: true): adds validTo, creationDate, executionDate, executedSellAmount, executedBuyAmount, txHash. Typical status values: open, fulfilled, unknown (with providerError when lookup fails).

Empty pending example

{
  "strategyId": "Ondo-AAPL-bsc",
  "wallet": "0x…",
  "hasPending": false,
  "orderBook": {
    "requestLend": { "canOpenOrder": true, "code": null, "errorType": null, "message": null, "retryable": false, "probeSellAmount": "100000000000000000000" },
    "requestWithdraw": { "canOpenOrder": true, "code": null, "errorType": null, "message": null, "retryable": false, "probeSellAmount": "1000000000000000000" }
  },
  "message": "No pending actions for this strategy. You are all caught up.",
  "actions": []
}

Suggested polling: every 5–15 s while hasPending is true, or until suw.phase reaches a terminal value. Example

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/status?wallet=0xYOUR_WALLET"

Non-Ondo strategies return the same root envelope without orderBook or suw.

WebSocket (recommended)

wss://<api-host>/updates

{ "type": "subscribe", "channel": "<walletAddress>" }

Listen for action_update events where action.id matches the bytecode response id:

Status	Meaning
`PENDING`	Awaiting settlement
`SUCCESS`	Order filled
`FAILED`	Order failed
`REFUNDED`	Order refunded

Re-subscribe on reconnect. Alternatively, use your customer webhook (ACTION_UPDATE events).

History

Embedded in GET /v2/wallets/:address?include=all&fromActions=1 or:

GET /wallets/:wallet/history/:strategyId

Market-share buys appear as SAMECHAIN_INVESTMENT_DEPOSIT; sells as SAMECHAIN_INVESTMENT_WITHDRAW. Ignore INITIAL status (quote artifact).

Refresh positions

Refetch wallet/strategy endpoints after on-chain confirmation and after WebSocket SUCCESS.

8. Supported chains & USDC addresses

Stocks & ETFs settle on BSC; funding (buy) and payout (sell) can use any supported USDC chain.

Network	Chain ID	USDC decimals	USDC address
BSC	`56`	18	`0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d`
Base	`8453`	6	`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`
Arbitrum	`42161`	6	`0xaf88d065e77c8cC2239327C5EDb3A432268e5831`
Polygon	`137`	6	`0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359`

When fromChainId / toChainId are set, fromTokenAddress / toTokenAddress are required — the API does not default to USDC. Omission returns 422 VALIDATION_ERROR. A non-USDC funding or payout token may add an extra same-chain swap leg.

9. Errors

Code	HTTP	When
`REQUEST_LEND_AMOUNT_TOO_LOW`	422	Buy below $10 USDC
`LEND_AMOUNT_TOO_SMALL`	422	Amount too small for quote
`WITHDRAW_AMOUNT_TOO_SMALL`	422	Sell amount too small
`WITHDRAW_AMOUNT_REQUIRED`	400	Missing `amount`/`amountInShares`
`FROM_TOKEN_NOT_SUPPORTED`	400	Funding token not supported
`FROM_TOKEN_REQUIRED`	400	Crosschain buy without funding token
`CROSSCHAIN_BRIDGE_NO_OUTPUT`	422	Bridge returned no USDC for the buy
`USDC_NOT_SUPPORTED`	400	USDC not configured for the chain
`UNSUPPORTED_CHAIN`	400	Unknown `fromChainId`/`toChainId`
`QUOTE_NOT_FOUND`	404	Re-quote
`QUOTE_EXPIRED`	400	Re-quote
`VALIDATION_ERROR`	422	Missing `fromTokenAddress`/`toTokenAddress` when chain ID set; other schema failures
`FORBIDDEN`	403	`GET /tokens` without `wallet` in customer `productType`
`NO_API_KEY` / `INVALID_API_KEY`	401	Auth failure

Preserve error.code in your UI for user-friendly messages.

10. Integration notes

Use the correct actions: request-lend (buy) and request-withdraw (sell). Do not use the generic lend/withdraw.
Sign on the right chain: buy = funding chain (chainIdIn); sell = always BSC; position = BSC wallet.
Atomic bytecode: never send bytecode[] legs as separate transactions — see Executing Bytecode.
Async completion: after the origin tx, Pods completes bridge (if crosschain) + order fill; monitor via the action status, position, or history.
Sells use shares: pass amountInShares (18 decimals), not amount. Gate sells on wallet position (currentPositionInShares) and suw.phase !== 'awaiting_forward'.
Wallet output: EOA → output=bytecode + EIP-7702; smart account → output=userOperation; Fireblocks → output=fireblocks + accountId.
Same EVM wallet works across funding/payout chains; the market-share position always lives on BSC.

Minimal example

Buy $10 of AAPL from Base (crosschain):

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/bytecode\
?action=request-lend&amount=10000000&wallet=0xYOUR_WALLET\
&fromChainId=8453&fromTokenAddress=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"

Sign response.bytecode (legs where chainId === 8453) on Base, then poll:

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc?wallet=0xYOUR_WALLET&fromActions=1"

Sell shares, receive USDC on Arbitrum (crosschain):

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/bytecode\
?action=request-withdraw&amountInShares=1000000000000000000&wallet=0xYOUR_WALLET\
&toChainId=42161&toTokenAddress=0xaf88d065e77c8cC2239327C5EDb3A432268e5831"

Sign response.bytecode (legs where chainId === 56) on BSC, then poll the position until the pending arrays clear.

Endpoint reference

Concern	Method & Path
Market open?	`GET /ondo/stocks/market-status`
List Stocks & ETFs	`GET /tokens?category=stock&chainId=56`
List strategies	`GET /v2/strategies?protocol=Ondo&network=bsc`
Strategy + position	`GET /v2/strategies/:id?wallet=<addr>&fromActions=1`
Position per wallet	`GET /v2/wallets/:addr/strategies/:id`
Quote + bytecode	`GET /strategies/:id/bytecode`
Pending actions	`GET /strategies/:id/status?wallet=<addr>`
Wallet snapshot	`GET /v2/wallets/:addr?include=all`
History	`GET /wallets/:wallet/history/:strategyId`
Status updates	`wss://<host>/updates`

All HTTP endpoints require x-api-key.

​Overview

​Authentication

​Integration flow

​1. Market status

​2. List Stocks & ETFs

​3. Resolve strategy ID

​4. Buy — request-lend

​5. Sell — request-withdraw

​6. Positions & pending requests

​Wallet snapshot (all positions)

​Single strategy position

​Position shape

​requestedTo* fields

​Available balance for sell

​7. Track order status

​HTTP — pending actions for one strategy

​What appears in actions[]

​Root response (always)

​Each item in actions[]

​suw.phase lifecycle

​suw.order shapes

​Empty pending example

​WebSocket (recommended)

​History

​Refresh positions

​8. Supported chains & USDC addresses

​9. Errors

​10. Integration notes

​Minimal example

​Endpoint reference

Overview

Authentication

Integration flow

1. Market status

2. List Stocks & ETFs

3. Resolve strategy ID

4. Buy — `request-lend`

5. Sell — `request-withdraw`

6. Positions & pending requests

Wallet snapshot (all positions)

Single strategy position

Position shape

`requestedTo*` fields

Available balance for sell

7. Track order status

HTTP — pending actions for one strategy

What appears in `actions[]`

Root response (always)

Each item in `actions[]`

`suw.phase` lifecycle

`suw.order` shapes

Empty pending example

WebSocket (recommended)

History

Refresh positions

8. Supported chains & USDC addresses

9. Errors

10. Integration notes

Minimal example

Endpoint reference