# pendle api

> ## Terms used in the documentation/API Below are some terms used in the documentation/API: - Pendle Assets/Tokens: PT, YT, LP, SY - Non-Pendle Assets: other tokens that are not Pendle assets, such as USDC, USDT, DAI, etc. - Asset ID/Token Id: Is the combination of chain id and token address, e.g. 1-0x5fe30ac5cb1abb0e44cdffb2916c254aeb368650 - Computing unit: Cost of an API call, this is use to rate limit the API calls. More on it at [our document](https://docs.pendle.finance/pendle-v2/Developers

MCP endpoint: https://aarna.mcp.junct.dev/mcp
Domain: dex
Auth: none

## Tools

## Read

### limit_orders_controller_get_all_limit_orders
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

**Parameters:**
- `chainId` (number, optional): Chain id to filter by, leave blank to fetch all chains.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 1000.
- `maker` (string, optional): Maker address to filter orders by
- `yt` (string, optional): Market address to filter orders by
- `timestamp_start` (string, optional): query parameter: timestamp_start (string)
- `timestamp_end` (string, optional): query parameter: timestamp_end (string)
- `resumeToken` (string, optional): Resume token for pagination

### limit_orders_controller_get_all_archived_limit_orders
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, ... }[], ... }.

**Parameters:**
- `chainId` (number, optional): Chain id to filter by, leave blank to fetch all chains.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 1000.
- `maker` (string, optional): Maker address to filter orders by
- `yt` (string, optional): Market address to filter orders by
- `timestamp_start` (string, optional): query parameter: timestamp_start (string)
- `timestamp_end` (string, optional): query parameter: timestamp_end (string)
- `resumeToken` (string, optional): Resume token for pagination

### limit_orders_controller_get_maker_limit_order
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, ... }.

**Parameters:**
- `skip` (number, optional): Number of results to skip. The parameter is capped at 1000.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 100.
- `chainId` (number, required): ChainId
- `maker` (string, required): Maker's address
- `yt` (string, optional): Order's YT address
- `type` (number, optional): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `isActive` (boolean, optional): isActive=true to get all maker's active orders, isActive=false otherwise and do not set isActive if you want to fetch all maker's orders

### limit_orders_controller_get_taker_limit_orders
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, ... }.

**Parameters:**
- `skip` (number, optional): Number of results to skip. The parameter is capped at 1000.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 100.
- `chainId` (number, required): ChainId
- `yt` (string, required): Order's YT address
- `type` (number, required): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `sortBy` (string, optional): query parameter: sortBy ("Implied Rate")
- `sortOrder` (string, optional): query parameter: sortOrder ("asc" | "desc")

### limit_orders_controller_get_limit_order_book_v2
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

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 200.
- `precisionDecimal` (number, required): Min: 0, Max: 3, returned impliedApy will have precision upto 10^{-precisionDecimal}%
- `market` (string, required): Market address
- `includeAmm` (boolean, optional): Include AMM orders in the order book

### prices_cross_chain_controller_get_all_asset_prices_by_addresses_cross_chains
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, ... }.

**Parameters:**
- `ids` (string, optional): Token ids to data for (comma-separated), leave blank to fetch all tokens. Up to 20 ids allowed.
- `chainId` (number, optional): Chain id to filter by, leave blank to fetch all chains.
- `skip` (number, optional): Number of results to skip.
- `limit` (number, optional): Maximum number of results to return. Leave blank to fetch all results.
- `type` (string, optional): Asset types to filter by (comma-separated). Valid values: `PENDLE_LP`, `SY`, `PT`, `YT`. Leave blank to fetch all assets types.

### prices_controller_ohlcv_v4
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

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `address` (string, required): path parameter: address (string)
- `time_frame` (string, optional): Time interval for OHLCV data aggregation. Valid values: `hour`, `day`, `week`.
- `timestamp_start` (string, optional): ISO Date string of the start time you want to query
- `timestamp_end` (string, optional): ISO Date string of the end time you want to query

### assets_cross_chain_controller_get_pendle_assets_metadata
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

**Parameters:**
- `ids` (string, optional): Token ids to data for (comma-separated), leave blank to fetch all tokens. Up to 20 ids allowed.
- `chainId` (number, optional): Chain id to filter by, leave blank to fetch all chains.
- `skip` (number, optional): Number of results to skip.
- `limit` (number, optional): Maximum number of results to return. Leave blank to fetch all results.
- `type` (string, optional): Asset types to filter by (comma-separated). Valid values: `PENDLE_LP`, `SY`, `PT`, `YT`. Leave blank to fetch all assets types.

### markets_cross_chain_controller_get_all_markets
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, ... }[] }.

**Parameters:**
- `isActive` (boolean, optional): Filter to active or inactive markets
- `chainId` (number, optional): Filter to markets on a specific blockchain network
- `ids` (string, optional): Market ids to fetch metadata for (comma-separated), leave blank to fetch all markets. Up to 20 ids allowed.

### markets_cross_chain_controller_get_points_markets
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[] }[] }.

**Parameters:**
- `isActive` (boolean, optional): Filter to active or inactive markets
- `chainId` (number, optional): Filter to markets on a specific blockchain network

### markets_controller_market_data_v2
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 }, ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `address` (string, required): path parameter: address (string)
- `timestamp` (string, optional): query parameter: timestamp (string)

### markets_controller_market_historical_data_v2
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

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `address` (string, required): path parameter: address (string)
- `time_frame` (string, optional): query parameter: time_frame ("hour" | "day" | "week")
- `timestamp_start` (string, optional): query parameter: timestamp_start (string)
- `timestamp_end` (string, optional): query parameter: timestamp_end (string)
- `fields` (string, optional): Comma-separated list of fields to include in the response. Use `all` to include all fields. Available fields could be found in the table above. Although you could use `all` to include all fields, it is not recommended because the bigger the payload is, the slower the response will be.
- `includeFeeBreakdown` (boolean, optional): Whether you want to fetch fee breakdown data. Default is false. If enable, the response will include 3 fields: explicitSwapFee, implicitSwapFee, limitOrderFee and computing unit cost will be doubled. Fee breakdown is only available for daily and weekly timeframes.

### ve_pendle_controller_ve_pendle_extended_data
[Deprecated] Get vePendle statistics — **Deprecated**: vePENDLE has been replaced by sPENDLE. This endpoint returns vePENDLE governance data and will not reflect the new sPENDLE staking system. Returns aggregate vePENDLE governance statistics, updated every 5 minutes. The response includes: - **Revenue**: cumulative and monthly protocol revenue from swap fees - **PENDLE supply**: current circulating and total supply - **Voting epoch data**: per-pool vote counts, swap fees, and voter APR for both the current and previous epoch - **Pool caps**: the vePENDLE vote weight cap per pool for this epoc

_No parameters required._

### ve_pendle_controller_all_market_total_fees
[Deprecated] Get market fees chart — **Deprecated**: vePENDLE has been replaced by sPENDLE. The epoch-based fee distribution model no longer applies. Returns weekly trading fee revenue across all Pendle markets, grouped by voting epoch (epochs start on Thursdays). Useful for tracking protocol revenue trends and understanding which markets generate the most fee income. Filter by date range using `timestamp_start` and `timestamp_end` (Unix seconds). Returns: { results: { market: unknown, values: unknown[] }[] }.

**Parameters:**
- `timestamp_start` (string, optional): Should be rounded up to time frame (in UTC)
- `timestamp_end` (string, optional): Should be rounded up to time frame (in UTC)

### sdk_controller_get_market_tokens
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[], ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `market` (string, required): path parameter: market (string)

### sdk_controller_get_supported_aggregators
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

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)

### sdk_controller_get_market_spot_swapping_price
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, ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `market` (string, required): path parameter: market (string)

### sdk_controller_cancel_single_limit_order
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[][], ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `userAddress` (string, required): User Address
- `salt` (string, required): BigInt string of salt
- `expiry` (string, required): BigInt string of expiry
- `nonce` (string, required): BigInt string of nonce
- `orderType` (number, required): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `token` (string, required): Token used by user to make order
- `YT` (string, required): YT address
- `maker` (string, required): Maker address
- `receiver` (string, required): Receiver address
- `makingAmount` (string, required): BigInt string of making amount
- `lnImpliedRate` (string, required): BigInt string of lnImpliedRate (natural logarithm of the implied rate)
- `failSafeRate` (string, required): BigInt string of failSafeRate
- `permit` (string, required): Bytes string for permit

### sdk_controller_cancel_all_limit_orders
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[][], ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `userAddress` (string, required): User Address

### sdk_controller_redeem_interests_and_rewards
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[][], ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `receiver` (string, required): The address to receive the output of the action
- `sys` (string, optional): Use comma separated values to search by multiple addresses
- `yts` (string, optional): Use comma separated values to search by multiple addresses
- `markets` (string, optional): Use comma separated values to search by multiple addresses

### sdk_controller_convert
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 | |-------------------------------------------------------|-----------------------|-----------------|------------------------------------------------

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `receiver` (string, optional): Recipient address for transaction output
- `slippage` (number, required): Maximum slippage tolerance (0-1, where 0.01 equals 1%)
- `enableAggregator` (boolean, optional): Enable swap aggregator to swap between tokens that cannot be natively converted from/to the underlying asset
- `aggregators` (string, optional): List of aggregator names to use for the swap. If not provided, all aggregators will be used.List of supported aggregator can be found at: [getSupportedAggregators](#tag/sdk/get/v1/sdk/{chainId}/supported-aggregators)
- `tokensIn` (string, required): Input token addresses, seperate by comma with no spaces
- `amountsIn` (string, required): Input token amounts in wei, seperate by comma with no spaces
- `tokensOut` (string, required): Output token addresses, seperate by comma with no spaces
- `redeemRewards` (boolean, optional): Redeem rewards
- `needScale` (boolean, optional): Aggregators needScale value, only set to true when amounts are updated onchain. When enabled, please make sure to buffer the amountIn by about 2%
- `additionalData` (string, optional): Available fields: `impliedApy`, `effectiveApy`. Comma separated list of fields to return. For example: `field1,field2`. More fields will consume more computing units.
- `useLimitOrder` (boolean, optional): To use limit orders when converting, default to true

### sdk_controller_swap_pt_cross_chain_v2
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

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `receiver` (string, optional): Recipient address for transaction output
- `slippage` (number, required): Maximum slippage tolerance (0-1, where 0.01 equals 1%)
- `enableAggregator` (boolean, optional): Enable swap aggregator to swap between tokens that cannot be natively converted from/to the underlying asset
- `aggregators` (string, optional): List of aggregator names to use for the swap. If not provided, all aggregators will be used.List of supported aggregator can be found at: [getSupportedAggregators](#tag/sdk/get/v1/sdk/{chainId}/supported-aggregators)
- `pt` (string, required): PT token address
- `exactPtIn` (string, required): Exact amount value PT in
- `tokenOut` (string, required): Output token address

### sdk_controller_get_pt_cross_chain_metadata
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 }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `pt` (string, required): path parameter: pt (string)

### transactions_controller_transactions_v5
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, ... }.

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `address` (string, required): path parameter: address (string)
- `type` (string, optional): Transaction type to filter by. Valid values: `TRADES`, `LIQUIDITY`.
- `minValue` (number, optional): Minimum transaction value filter in USD
- `txOrigin` (string, optional): Address of the transaction executor
- `action` (string, optional): Specific transaction action to filter by. Valid values: `LONG_YIELD`, `SHORT_YIELD`, `ADD_LIQUIDITY`, `REMOVE_LIQUIDITY`.
- `resumeToken` (string, optional): Resume token for pagination. Use this to continue a previous query.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 1000.
- `skip` (number, optional): Use `resumeToken` instead.

### statistics_controller_get_distinct_user_from_token
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[] }.

**Parameters:**
- `token` (string, required): Token address to query. Can be any Pendle token (PT, YT, SY, LP). Address will be normalized to lowercase.
- `chainId` (number, optional): Optional chain ID to filter results. If provided, returns only users who interacted with the token on the specified chain. If omitted, returns users across all chains where the token exists.

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

_No parameters required._

### dashboard_controller_get_user_positions
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:

**Parameters:**
- `user` (string, required): path parameter: user (string)
- `filterUsd` (number, optional): Minimum USD value threshold to filter positions

### dashboard_controller_get_merkle_claimed_rewards
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, ... }[] }.

**Parameters:**
- `user` (string, required): Ethereum address of the user

### transactions_controller_get_transactions
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

**Parameters:**
- `skip` (number, optional): Number of results to skip. The parameter is capped at 1000.
- `limit` (number, optional): Maximum number of results to return. The parameter is capped at 1000.
- `chainId` (number, optional): Chain ID
- `user` (string, required): query parameter: user (string)
- `market` (string, optional): Market address

### pendle_emission_controller_pendle_emission
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, ... }[] }.

_No parameters required._

## Write

### limit_orders_controller_create_order
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

**Parameters:**
- `chainId` (number, required): Chain Id
- `signature` (string, required): Signature of order, signed by maker
- `salt` (string, required): BigInt string of salt
- `expiry` (string, required): BigInt string of expiry
- `nonce` (string, required): BigInt string of nonce
- `type` (number, required): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `token` (string, required): Token used by user to make order
- `yt` (string, required): YT address
- `maker` (string, required): Maker address
- `receiver` (string, required): Receiver address
- `makingAmount` (string, required): BigInt string of making amount
- `lnImpliedRate` (string, required): BigInt string of lnImpliedRate
- `failSafeRate` (string, required): BigInt string of failSafeRate
- `permit` (string, required): Bytes string for permit

### limit_orders_controller_generate_limit_order_data
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, ... }.

**Parameters:**
- `chainId` (number, required): Chain Id
- `YT` (string, required): YT address
- `orderType` (number, required): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `token` (string, required): Input token if type is TOKEN_FOR_PT or TOKEN_FOR_YT, output token otherwise
- `maker` (string, required): Maker address
- `makingAmount` (string, required): BigInt string of making amount, the amount of token if the order is TOKEN_FOR_PT or TOKEN_FOR_YT, otherwise the amount of PT or YT
- `impliedApy` (number, required): Implied APY of this limit order
- `expiry` (string, required): Timestamp of order's expiry, in seconds

### limit_orders_controller_generate_scaled_limit_order_data
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, ... }[] }.

**Parameters:**
- `chainId` (number, required): Chain Id
- `YT` (string, required): YT address
- `orderType` (number, required): LimitOrderType { 0 : TOKEN_FOR_PT, 1 : PT_FOR_TOKEN, 2 : TOKEN_FOR_YT, 3 : YT_FOR_TOKEN }
- `token` (string, required): Input token if type is TOKEN_FOR_PT or TOKEN_FOR_YT, output token otherwise
- `maker` (string, required): Maker address
- `makingAmount` (string, required): BigInt string of making amount, the amount of token if the order is TOKEN_FOR_PT or TOKEN_FOR_YT, otherwise the amount of PT or YT
- `lowerImpliedApy` (number, required): Lower implied APY of this scaled order
- `upperImpliedApy` (number, required): Upper implied APY of this scaled order
- `orderCount` (number, required): Upper implied APY of this scaled order
- `sizeDistribution` (string, required): Scaled Order Distribution Type { }
- `expiry` (string, required): Timestamp of order's expiry, in seconds

### sdk_controller_convert_v3
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 | |-------------------------------------------------------|-----------------------|-----------------|--------------

**Parameters:**
- `chainId` (number, required): path parameter: chainId (number)
- `receiver` (string, optional): Recipient address for transaction output
- `slippage` (number, required): Maximum slippage tolerance (0-1, where 0.01 equals 1%)
- `enableAggregator` (boolean, optional): Enable swap aggregator to swap between tokens that cannot be natively converted from/to the underlying asset
- `aggregators` (array, optional): List of aggregator names to use for the swap. If not provided, default aggregators will be used.List of supported aggregator can be found at: [getSupportedAggregators](#tag/sdk/get/v1/sdk/{chainId}/supported-aggregators)
- `inputs` (array, required): List of input tokens and their amounts
- `outputs` (array, required): Output token addresses
- `redeemRewards` (boolean, optional): Redeem rewards
- `needScale` (boolean, optional): Aggregators needScale value, only set to true when amounts are updated onchain. When enabled, please make sure to buffer the amountIn by about 2%
- `additionalData` (string, optional): Available fields: `impliedApy`, `effectiveApy`. Comma separated list of fields to return. For example: `field1,field2`. More fields will consume more computing units.
- `useLimitOrder` (boolean, optional): To use limit orders when converting, default to true
- `okxSwapParams` (object, optional): okxSwapParams ({ fromTokenReferrerWalletAddress: string, toTokenReferrerWalletAddress: string, feePercent: number, positiveSlippagePercent: number })

## Usage

Connect to this MCP server at `https://aarna.mcp.junct.dev/mcp`. All tools are callable via the MCP protocol.
Call `limit_orders_controller_get_all_limit_orders` first to query current state before any write operations.
Write operations like `limit_orders_controller_create_order` return data or calldata for agent use.