io.github.junct-bot/aarna-mcp

Get all limit orders for analytics — This endpoint is for analytics purpose, if you want to analyze the limit orders data, this endpoint return all the orders that have been made, including the ones that have been cancelled or fully filled. The results could be very large, so each time we returns at most 1000 orders, you can use the resumeToken to fetch the next page. To get limit order for filling, use the [Get limit orders to match by YT address​](#tag/limit-orders/get/v1/limit-orders/takers/limit-orders) endpoint! Returns: { total: number, limit: number, results: { id: string, signature: st

Get all archived limit orders for analytics — This have the same interface and usecase as the endpoint above, but it returns the archived orders When an order is not fillable anymore, we **might** archive it to save storage space, to fetch it, use this endpoint. So to fetch full limit orders in history, using this and the endpoint above. Not all orders are archived, it depends on some conditions. Returns: { total: number, limit: number, results: { id: string, signature: string, chainId: number, salt: string, expiry: string, nonce: string, ... }[], ... }.

Get user limit orders in market — Returns the active and historical limit orders placed by a specific user in a market. Supports richer filtering than the analytics endpoint (e.g. by YT, status, market). A user can have at most 50 open orders per market, so pagination is typically unnecessary here. For full cross-user analytics with cursor-based pagination, use [Get all limit orders](#tag/limit-orders/get/v2/limit-orders) instead. Returns: { total: number, limit: number, skip: number, ... }.

Create limit order — Submit a signed limit order to the Pendle order book. Once created, the order is visible to takers and will be filled against incoming swaps at or better than the specified implied APY. Before calling this, generate the order payload via [Generate limit order data](#tag/limit-orders/post/v1/limit-orders/makers/generate-limit-order-data), sign it with your wallet, and include the signature in the request body. Common rejection reasons: the YT or market is not whitelisted for limit orders, the order has already expired, or the signature is invalid. Returns: { id: string, sig

Generate limit order data for signing — Generate the EIP-712 typed data payload for a limit order. Sign the returned data with the maker's private key, then submit the order via [Create limit order](#tag/limit-orders/post/v1/limit-orders/makers/limit-orders). The generated order specifies the YT address, direction (long or short yield), size, and implied APY target. The order remains valid until it is either fully filled, cancelled, or expired. Returns: { chainId: number, YT: string, salt: string, ... }.

Generate list of limit orders (scaled) for signing — Generate a batch of limit orders spread across a price (implied APY) range for signing. Scaled orders distribute your total size across multiple price levels, providing better market depth than a single large order. Sign each generated order individually, then submit them via [Create limit order](#tag/limit-orders/post/v1/limit-orders/makers/limit-orders). Useful for market-making strategies. Returns: { orders: { chainId: number, YT: string, salt: string, expiry: string, nonce: string, token: string, ... }[] }.

Get limit orders to match by YT address — Returns the best-matching active limit orders for a given YT address, sorted by implied APY for efficient taker fill selection. The response includes full order structs and maker signatures ready to pass directly to the Pendle limit order contract for on-chain settlement. Only active orders (unfilled, uncancelled, unexpired) are returned. For analytics and full order history (including filled/cancelled), use [Get all limit orders](#tag/limit-orders/get/v2/limit-orders) instead. Returns: { total: number, limit: number, skip: number, ... }.

Get order book v2 — Returns the consolidated order book for a market, aggregating both limit orders and AMM liquidity depth into a unified view. The book is split into two sides: - **longYieldEntries**: available liquidity for buying YT (long yield positions), ordered by ascending implied APY - **shortYieldEntries**: available liquidity for selling YT (short yield positions), ordered by descending implied APY Each entry shows the implied APY price level, combined limit order size, and AMM depth at that level. Returns: { longYieldEntries: { impliedApy: number, limitOrderSize: number, ammSize: n

Get asset prices (cross-chain) — Returns USD prices for Pendle-supported tokens across all chains. Covers all token types in the Pendle app, including non-Pendle tokens (USDC, WETH, etc.) when they appear as underlying assets. Prices update approximately every minute. Filter by `chainId`, asset `id`, or `type` to narrow results. For real-time PT/YT pre-trade prices that reflect current pool depth, use [Get swapping prices](#tag/sdk/get/v1/sdk/{chainId}/markets/{market}/swapping-prices) instead. Returns: { prices: object, total: number, skip: number, ... }.

Get PT / YT / LP historical price by address — Historical price data for PT / YT tokens / LP tokens. We do not support historical prices for **SY and non-Pendle tokens**. The data is OHLCV data, returned in CSV format with open, high, low, close prices, and volume. In the case of LP, volume data will be 0. To get the correct volume, use our [Get market time-series data by address](#tag/markets/get/v2/{chainId}/markets/{address}/historical-data) endpoint. Returns at most 1440 data points. The cost for the endpoint is based on how many data points are returned. The calculation is: `ceil(number o

Get all assets (cross-chain) — Returns the flat list of all PT, YT, LP, and SY tokens supported in the Pendle app, across all chains. Each entry includes: name, symbol, contract address, decimals, expiry timestamp (for PT/YT), and icon URL. Filter by `chainId`, asset `id`, or `type` (pt, yt, lp, sy). Prices are not included — use [Get asset prices](#tag/assets/get/v1/prices/assets) to retrieve them separately. For chain-specific asset lists with richer metadata and prices bundled, use the chain-scoped [Get all assets](#tag/assets/get/v1/{chainId}/assets/all) endpoint instead. Returns: { assets

Get all markets (cross-chain) — Returns the complete list of whitelisted Pendle markets across all supported chains with their metadata and current data. Filter by `chainId`, `isActive`, or `ids` (comma-separated market IDs in `chainId-address` format). This is the recommended starting point for discovering and monitoring Pendle markets across all chains. For chain-scoped data with additional fields, use [Get markets](#tag/markets/get/v1/{chainId}/markets) instead. Returns: { markets: { name: string, address: string, expiry: string, pt: string, yt: string, sy: string, ... }[] }.

Get points markets — Returns all active markets that have a points reward programme — markets where trading or providing liquidity earns points from the underlying protocol. The response includes the points configuration for each market (point name, reward rate, etc.) and the associated market ID. To fetch full market metadata for these markets, call [Get all markets](#tag/markets/get/v1/markets/all) and filter by the returned IDs. Returns: { markets: { id: string, points: unknown[] }[] }.

Get latest/historical market data by address — Returns the latest or historical data snapshot for a given market. Pass a `timestamp` query param (Unix seconds) to retrieve the market state at a specific point in time. Omit it for the current snapshot. For time-series data (charts/analytics), prefer the [historical-data](#tag/markets/get/v2/{chainId}/markets/{address}/historical-data) endpoint. Returns: { timestamp: string, liquidity: { usd: number, acc: number }, tradingVolume: { usd: number, acc: number }, ... }.

Get market time-series data by address — Returns the time-series data for a given market. Useful to draw charts or do data analysis. This endpoint supports field selection via the `fields` query parameter. Table below shows the available fields and their descriptions. | Field | Description | |-------|-------------| | timestamp | Timestamp in ISO format| | baseApy | APY including yield, swap fee and Pendle rewards without boosting| | impliedApy | Implied APY of market| | lastEpochVotes | Last epoch votes| | lpPrice | LP price in USD| | lpRewardApy | APY from LP reward tokens| | maxApy | APY whe

Get supported tokens for market — Returns the two sets of tokens relevant for a given market: - **SY input tokens**: tokens accepted by the SY wrapper for minting/redeeming (e.g. USDC for a USDC-based market). - **Zap tokens**: tokens that can be used as input when buying PT/YT or providing liquidity, routed via aggregators. Call this before building a Convert or Swap request to know which input tokens are valid for a given market. Returns: { tokensMintSy: string[], tokensRedeemSy: string[], tokensIn: string[], ... }.

Get supported aggregators for a chain — Returns the list of DEX aggregators available on this chain for routing token swaps, along with the additional computing unit cost each one adds to SDK requests. Use this to decide which aggregators to include in Convert/Swap calls via the `aggregators` query param. You can reduce any aggregator's CU cost to 0 by providing your own API key in the corresponding request header. See [Reducing Aggregator Costs](https://docs.pendle.finance/pendle-v2/Developers/Backend/HostedSdk#reduce-aggregator-computing-units) for details. Returns: { aggregators: { name: st

Get real-time PT/YT swap price of a market — Return price by swapping 1 unit underlying token to PT/ YT, and 1 unit of PT/YT to the underlying token. One unit is defined as 10**decimal. The result is updated every block. Implied APY of the market is also included. Returns: { underlyingToken: string, underlyingTokenToPtRate: object, ptToUnderlyingTokenRate: object, ... }.

Cancel one single limit order by order hash — Generate the transaction payload to cancel a specific limit order on-chain. Pass the full signed order struct (from the original order creation) to identify which order to cancel. The order becomes invalid once the cancellation transaction is confirmed. Returns: { method: string, contractCallParamsName: string[], contractCallParams: unknown[][], ... }.

Cancel all limit orders — Generate the transaction payload to cancel all active limit orders for a user in a single on-chain call. This works by incrementing the user's nonce on-chain, which invalidates all previously signed orders at once. More efficient than cancelling orders one by one when clearing all open positions. Returns: { method: string, contractCallParamsName: string[], contractCallParams: unknown[][], ... }.

Redeem rewards and interests from positions — Generate a transaction payload to claim all accrued interest and incentive rewards across multiple positions in a single call. Specify which positions to claim from by passing arrays of: - `sys`: SY token addresses (to claim SY interest) - `yts`: YT token addresses (to claim YT interest and rewards) - `markets`: LP market addresses (to claim LP rewards) Useful for portfolio management bots or dashboards that batch-claim on behalf of users. Returns: { method: string, contractCallParamsName: string[], contractCallParams: unknown[][], ... }.

Universal convert function — The **Convert API** is the recommended endpoint for all Pendle transaction building. It supersedes the individual swap, add/remove liquidity, mint, redeem, transfer, and exit endpoints — handling 21 distinct operations through a unified interface. The action is automatically detected from your `tokensIn` and `tokensOut` addresses. See the table below for all supported operations. | Action | tokensIn | tokensOut | Note | |-------------------------------------------------------|-----------------------|-----------------|------------------------------------------------

Universal convert function (recommended — POST body variant) — The **Convert API** is the recommended endpoint for all Pendle transaction building. It supersedes the individual swap, add/remove liquidity, mint, redeem, transfer, and exit endpoints — handling 21 distinct operations through a unified interface. The action is automatically detected from your `tokensIn` and `tokensOut` addresses. See the table below for all supported operations. | Action | tokensIn | tokensOut | Note | |-------------------------------------------------------|-----------------------|-----------------|--------------

Swap PT using fixed price AMM for cross-chain operations — Swap a bridged PT on a spoke chain back to a regular token using the fixed-price PT AMM. This is specifically for **cross-chain PT redemption flows** where PT has been bridged to a non-primary chain. The fixed-price AMM prices PT based on time-to-maturity, independent of pool liquidity. Supports both: - Exact PT input → token output - Exact token output ← PT input (pass the required token amount; the system calculates PT needed) Only valid on supported spoke chains. Returns: { method: string, contractCallParamsName: string[], contractC

PT cross-chain metadata — Returns metadata for a PT that has been bridged to a spoke chain, including maturity, underlying asset details, and fixed-price AMM parameters. Use this to verify that a bridged PT is supported on the current chain and to fetch its pricing parameters before calling [Swap PT cross-chain](#tag/sdk/get/v2/{chainId}/swap-pt-cross-chain). Returns: { pairedTokensOut: string[], ammAddress: string }.

Get market transactions by address — Return transactions with: user action (long or short yield, add or remove liquidity), valuation, implied apy. **Pagination**: This endpoint supports cursor-based pagination using `resumeToken`. The response includes a `resumeToken` field that can be used in the next request to fetch the next page of results. This is more efficient than using `skip` for large datasets. Returns: { total: number, resumeToken: string, limit: number, ... }.

Get distinct users for a specific token — Returns a list of unique wallet addresses that have interacted with a specific token across Pendle markets. Use the optional `chainId` parameter to filter results to a specific chain, or omit it to get users across all chains. Common use cases include: - Token holder analysis - User adoption metrics - Market participation statistics Returns: { users: string[] }.

Get supported chain IDs Returns: { chainIds: number[] }.

Get user positions by address — Returns a complete snapshot of a user's Pendle positions across all supported chains, including PT, YT, LP, and SY holdings. For each position the response includes token amounts, USD valuations, and claimable interest/reward amounts. **Caching**: claimable reward amounts are cached for up to 24 hours. For real-time claimable data, read directly from the reward contracts via RPC. Use the `chainId` query parameter to filter results to a specific chain. Returns: { positions: { chainId: number, totalOpen: number, totalClosed: number, totalSy: number, openPositions:

Get all merkle claimed rewards for a user — Returns the historical record of all merkle rewards that a user has already claimed. Useful for displaying claim history in a dashboard or verifying that a specific reward distribution has been collected. Returns: { claimedRewards: { user: string, token: string, merkleRoot: string, chainId: number, assetId: string, amount: string, ... }[] }.

Get user transaction history — Returns the on-chain transaction history for a user address across all Pendle operations. Results are paginated. Use the `resumeToken` from the response to fetch the next page. Data may lag chain tip by a few minutes due to indexing. Returns: { total: number, results: { chainId: number, market: string, user: string, timestamp: string, action: "addLiquidityDualTokenAndPt" | "addLiquiditySinglePt" | "addLiquiditySingleToken" | "addLiquiditySingleTokenKeepYt" | "removeLiquidityDualTokenAndPt" | "removeLiquidityToPt" | "removeLiquiditySingleToken" | "mintPy" | "redee

Get Pendle Emission — Returns the latest confirmed PENDLE emission across all eligible markets. Each market includes a breakdown of emission by TVL, fee, discretionary, and co-bribing components. Returns: { markets: { chainId: number, address: string, totalIncentive: number, tvlIncentive: number, feeIncentive: number, discretionaryIncentive: number, ... }[] }.