Pendle

Pendle (Spot): Trades Pendle PT (principal tokens) and YT (yield tokens). One exchange object corresponds to one wallet on one chain: market orders are swaps built by Pendle's convert API, limit orders rest on Pendle's limit order book, and the docker signs transactions and orders with the configured private key. Supported chains: Ethereum, Arbitrum, Base, BNB Chain, HyperEVM, Plasma, Robinhood, Monad, X Layer.

Futures_Boros (Futures): Trades Pendle Boros funding-rate swaps (Yield Units, YU): on an on-chain order book on Arbitrum, buy or sell the funding rate of perpetual exchanges (Hyperliquid, Binance, OKX, Gate, KuCoin, Bybit, Lighter and more) at a fixed annualized rate, settled hourly until maturity. One exchange object corresponds to one Boros sub-account (cross margin) of one wallet. Orders cost no ETH from the wallet: the docker derives an agent key from the wallet private key, the wallet approves it by signature before the first order, and every order is then signed by the agent and put on chain by Pendle's relayer, with the relay fee taken from the Boros account's gas balance.

Names and Configuration

✓ marks the exchange objects that have the field.

Trading Pairs and Contract Codes

Pendle (Spot)

Pair examples: PT-apyUSD-5NOV2026_apyUSD, YT-apyUSD-5NOV2026_USDC

The first part is the PT or YT name (with its expiry, taken from Pendle's asset list; see exchange.GetMarkets()) and the second part is the quote token. The price is how many quote tokens one PT/YT is worth. The quote can be the market's underlying asset, its accounting asset, or any other token Pendle can swap on the chain (market orders route through an aggregator), or a token contract address. Pairs are not upper-cased; write them as they are.

Futures_Boros (Futures)

Pair examples: BTC_USDT, ETH_ETH, BTC_BTC

Pairs are underlying_collateral: the underlying is the asset whose funding rate is traded, the collateral is the market's margin token (WBTC is written BTC, WETH ETH, USD₮0 USDT, plus BNB and HYPE). The same market name can exist with two collaterals (for example Hyperliquid BTC with USDT and with BTC margin); the collateral tells them apart. The price is the annualized rate as a decimal (0.065 means 6.5%) and can be negative; the amount is YU in the collateral token (in a USDT-margined market 1 YU is the funding on 1 USDT of notional).

Contract codes are Boros market names with underscores, funding source_asset_maturity, such as HYPERLIQUID_BTC_30OCT2026 or BINANCE_ETHUSDT_25DEC2026; a full symbol looks like BTC_USDT.HYPERLIQUID_BTC_30OCT2026. The Boros name itself (HYPERLIQUID-BTC-30OCT2026) also works. exchange.GetMarkets() lists the available markets (unmatured only). Boros's numeric market id (such as 206) also works.

Exchange-specific IO Commands

Pendle (Spot)

The rest of the longer descriptions in the table:

• orderExpiry: The order option expiry sets the expiry of one order as a timestamp in seconds or milliseconds (a point in time, not a duration); a time already past fails, and a time after the market's expiry becomes one minute before it. Queries when called without an argument.

For the common command currency see exchange.IO.

The common command api is not supported (the call fails with an error and returns null).

Futures_Boros (Futures)

For the common command currency see exchange.IO.

The common command api is not supported (the call fails with an error and returns null).

Common Usage

Read a PT market and convert between price and implied APY (Pendle only)

            javascript
            
            
function main() {
    var symbol = "PT-apyUSD-11FEB2027_apyUSD"
    var m = exchange.IO("market", symbol)
    if (!m) {
        Log("Market query failed:", GetLastError())
        return
    }
    Log(m.kind, m.name, "expiry:", _D(m.expiry), "years to expiry:", m.yearsToExpiry)
    Log("implied APY now:", m.impliedApy, "accounting asset per quote:", m.accountingPerQuote)
    var t = exchange.GetTicker(symbol)
    if (t) {
        // The APY locked in by buying at the best ask
        Log("ask:", t.Sell, "implied APY:", exchange.IO("apy", symbol, t.Sell))
    }
    // The buy price for an APY one point above the current one (a lower PT price)
    var price = exchange.IO("price", symbol, m.impliedApy + 0.01)
    Log("price for the target APY:", price)
}

Place a PT limit buy at a target APY and cancel it if it has not filled after a while (Pendle only)

            javascript
            
            
function main() {
    var symbol = "PT-apyUSD-11FEB2027_apyUSD"
    exchange.IO("orderExpiry", 86400)    // limit orders placed from now on expire after 1 day
    exchange.IO("approve", "max")        // approve the paying token in full (default: per order)
    exchange.IO("cancelWait", 60)        // wait up to 60 seconds for a cancel to be mined
    var m = exchange.IO("market", symbol)
    var apy = m.impliedApy + 0.01
    var price = exchange.IO("price", symbol, apy)
    var id = exchange.CreateOrder(symbol, "buy", price, 10)    // the amount is in PT
    if (!id) {
        Log("Order failed:", GetLastError())
        return
    }
    Log("limit order:", id, "price:", price, "APY:", apy)
    Sleep(10 * 60 * 1000)
    var o = exchange.GetOrder(id)
    if (o && o.Status == ORDER_STATE_PENDING) {
        // Canceling is an on-chain transaction and costs gas
        Log("cancel:", exchange.CancelOrder(id), "filled:", o.DealAmount)
    }
}

Buy PT at market, then read the transaction receipt (Pendle only)

            javascript
            
            
function main() {
    var symbol = "PT-apyUSD-11FEB2027_USDC"    // quoted in USDC, swapped through an aggregator
    exchange.IO("slippage", 0.003)              // 0.3% slippage protection
    var id = exchange.CreateOrder(symbol, "buy", -1, 20)    // market buy: spend 20 USDC
    if (!id) {
        Log("Swap failed:", GetLastError())
        return
    }
    // A swap order ID is "pair,txHash"; wait up to 2 minutes for it to be mined
    var r = exchange.IO("receipt", id.split(",")[1], 120000)
    Log("status:", r.status, "block:", r.blockNumber, "gas:", r.gasUsed, "fee:", r.fee)
    if (r.status == "success") {
        var o = exchange.GetOrder(id)
        Log("PT bought:", o.DealAmount, "average price:", o.AvgPrice)
    }
}

Check the trading agent and the gas balance, and top up gas by hand when it runs low (Futures_Boros only)

            javascript
            
            
function main() {
    Log("wallet:", exchange.IO("address"))
    var a = exchange.IO("agent")
    if (!a) {
        Log("Agent query failed:", GetLastError())
        return
    }
    Log("agent:", a.agent, "sub-account:", a.accountId, "approved:", a.approved)
    // Renew early when less than 3 days are left (wallet signature, relayed, no ETH spent)
    if (!a.approved || a.expiry - Date.now() / 1000 < 3 * 86400) {
        var r = exchange.IO("approveAgent")
        Log("agent approved until:", _D(r.expiry * 1000))
    }
    var gas = exchange.IO("gasBalance")
    Log("gas balance (USD):", gas)
    if (gas < 0.5) {
        var t = exchange.IO("topUpGas", 2, "USDT")    // pay $2 from the USDT cross cash
        Log("gas topped up:", t.paid, t.currency, t.txHash)
    }
    // Automatic top-up before orders: keep it on, paying $3 each time
    Log(exchange.IO("autoTopUp", true, 3))
}

Deposit from the wallet, move margin into an isolated-only market, then request a withdrawal (Futures_Boros only)

            javascript
            
            
function main() {
    // The wallet's (not the Boros account's) balances on Arbitrum
    var w = exchange.IO("wallet")
    for (var i = 0; i < w.length; i++) {
        Log(w[i].currency, w[i].amount)
    }
    // A wallet transaction: pays ETH gas from the wallet and returns once mined
    var d = exchange.IO("deposit", "USDT", 50)
    if (!d) {
        Log("Deposit failed:", GetLastError())
        return
    }
    Log("deposited", d.amount, d.currency, "into sub-account", d.accountId, d.txHash)
    // Isolated-only market: positive moves cash from cross into it, negative moves it back
    var iso = "BRENTOIL_USDT.HYPERLIQUID_XYZBRENTOIL_18NOV2026"
    Log(exchange.IO("isolatedTransfer", iso, 20))
    Log(exchange.IO("isolatedTransfer", iso, -20))
    // Request a withdrawal (from the cross account of sub-account 0 only), paid after cooldown
    var r = exchange.IO("withdraw", "USDT", 30)
    Log(r ? r.note : GetLastError())
    // Cancel during the cooldown with exchange.IO("cancelWithdraw", "USDT")
}

Read a market's mark rate and underlying funding rate, and see which tick a target rate rounds to (Futures_Boros only)

            javascript
            
            
function main() {
    var symbol = "BTC_USDT.HYPERLIQUID_BTC_27NOV2026"
    var r = exchange.IO("market", symbol)
    if (!r) {
        Log("Query failed:", GetLastError())
        return
    }
    var m = r.results[0]
    Log(m.imData.symbol, "market id:", m.marketId, "isolated only:", m.imData.isIsolatedOnly)
    Log("mark rate:", m.data.markApr, "underlying funding rate:", m.data.floatingApr,
        "next settlement:", _D(m.data.nextSettlementTime * 1000))
    // A long half a point below the mark rate: see which tick it rounds to first
    var t = exchange.IO("tick", symbol, m.data.markApr - 0.005, "buy")
    Log("tick:", t.tick, "actual rate:", t.rate, "tickStep:", t.tickStep)
}

Function Support

Pendle (Spot)

Not supported (the call fails with an error and returns null): exchange.GetTickers, exchange.GetRecords, exchange.GetTrades, exchange.ModifyOrder, exchange.CreateConditionOrder, exchange.ModifyConditionOrder, exchange.CancelConditionOrder, exchange.GetConditionOrder, exchange.GetConditionOrders, exchange.GetHistoryConditionOrders.

Futures_Boros (Futures)

Not supported (the call fails with an error and returns null): exchange.GetTickers, exchange.SetMarginLevel, exchange.ModifyConditionOrder.

Margin, Account and Simulation

Futures_Boros (Futures)

Margin mode: Ordinary markets use the cross account (one per collateral token, shared by every market of that collateral); isolated-only markets (some commodity funding-rate markets) use their own isolated account automatically, funded first with exchange.IO("isolatedTransfer", ...) or along with an order through the option cashIn. Boros has no leverage setting: the initial margin follows the position size, the rate and the time to maturity.

Position mode: One-way positions. Boros has no reduce-only flag: closing orders (closebuy, closesell) are opposite orders capped at the current position (the exact position size when within one part per billion of it), and fail without an order when there is no position in that direction.

Account: exchange.GetAccount() reads the cross account of the current pair's collateral (the isolated account for an isolated-only market): Balance is the available initial margin, FrozenBalance the initial margin in use, Equity the account's net value (cash plus position value). In exchange.GetPositions(), Price is the fixed annualized entry rate, Profit the unrealized PnL, and Margin the initial margin the position uses in the account that holds it (cross or isolated), all in the collateral; a matured position awaiting settlement has a Margin of 0.

Notes

Pendle (Spot)

Limit orders can only pay with or pay out tokens the market's SY accepts (usually the underlying and accounting assets); another quote token fails with the list of usable tokens. The token given is approved to the Pendle limit order contract automatically before placing; placing itself is off-chain and costs no gas, while canceling is an on-chain transaction.

Pendle's API is rate-limited by computing units (200 per minute: a swap quote costs at least 5, the order book 5, live prices 1). Keep market-data polling reasonable; when rate-limited the connector waits for the next minute and retries once.

Futures_Boros (Futures)

Every order and cancel goes on chain through Pendle's relayer and is paid from the Boros account's gas balance (about $0.02 to $0.04, see exchange.IO("gasBalance")); by default a low balance is topped up from the cross cash automatically (see exchange.IO("autoTopUp", ...)). Submissions of one exchange object run one at a time.

The Boros API is rate-limited by computing units: 200 per minute per IP (orders and cancels cost 5 each, the market list and order book 2 each, most others 1). When rate-limited the connector waits for the next window and retries once; keep market-data polling reasonable.

Risks: a funding-rate swap gains or loses with the difference between the underlying funding rate and the traded rate, and with position value changes as the implied rate moves; an account short of margin is liquidated. Funding settles hourly until maturity.