Discover live Merkl incentive campaigns on a given chain.

Returns all active Merkl campaigns with APR, reward tokens, daily rewards, TVL, and campaign type. Essential for understanding subsidized rates:

• Morpho borrow campaigns: Merkl can PAY borrowers, making net borrow cost negative

• LP campaigns: additional yield on top of base pool APR

• HOLD campaigns: rewards for simply holding a token

Use this to verify whether a borrow rate is subsidized, find new incentive opportunities, or understand the full yield stack of any position.

Campaign types: CLAMM (concentrated LP), ERC20LOGPROCESSOR (Morpho/lending), MORPHOVAULT, etc. Action types: POOL (LP only), HOLD (token holders), BORROW, LEND.

Data completeness: the underlying Merkl API is fully paginated (all campaigns fetched, not truncated) and cached 15min in-memory + 30min on disk. Chains like Ethereum mainnet have 1,800+ campaigns — all are indexed. When asset_filter is provided, it also applies server-side filtering for targeted lookups.

When an agent says "no subsidy exists" — check here first. The subsidy layer is invisible to protocol-native tools unless explicitly integrated.

Historical rates and growth for a specific Morpho market. Shows borrow APY, supply APY, utilization, and TVL trends over time with min/avg/max/current stats and directional signals.

Useful for assessing rate stability before entering a looping position. A market with stable, predictable borrow rates is safer for leveraged strategies than one with frequent spikes.

Output includes signals: rate spikes, stability assessments, utilization warnings, TVL decline alerts, and supply/demand squeeze detection.

Parameters:

• period: 7d (hourly), 30d (daily), 90d (daily), 1y (weekly)

• interval: auto-selected based on period, or override manually

Use morpho_get_rate for current live rates. Use morpho_list_markets to discover market keys. Use spectra_get_looping_strategy to model leveraged yield after confirming rate stability.

Show who supplies lending liquidity to a specific Morpho market. Returns top suppliers ranked by supply size, identifies Morpho vaults vs EOAs vs loopers, and provides concentration analysis.

A market's supply side determines looping viability. A high-APY market with $10K supply from a single vault has different risk/capacity than $10M from diverse sources.

Protocol context:

• Suppliers are identified via Morpho's marketPositions query, then cross-referenced against the vault registry. Addresses that aren't vaults could be EOAs or contracts.

• A supplier with both collateral and borrows is likely a looper, not a lender. The tool tags these as [Looper] — but this is inference from position shape, not confirmed. The address could be a contract doing something more complex.

• Supply concentration affects rate stability: one vault withdrawing could spike borrow rates. High concentration is a signal, not necessarily a problem.

• Reward incentives (supply APR) can make supply competitive — or mask thin organic yield.

Use morpho_list_markets to find market keys first. Use morpho_list_vaults to discover all vaults on a chain and their allocations. Use morpho_get_rate for borrow-side rate and PT spread analysis.

Query a user's Morpho positions across all markets and vaults on a chain. Returns collateral, borrows, supply (with USD values), vault deposits, health factors, and position signals (looper detection, low health warnings).

Useful for understanding what a wallet holds on Morpho: is it a looper? A supplier? A vault depositor? The position shape reveals the strategy.

Protocol context:

• Market positions show collateral, borrows, and supply separately. A position with both collateral and borrows is likely a looper (leveraged strategy).

• Health factor = (collateralUsd * LLTV) / borrowUsd — approximation using USD values. Health < 1.0 means liquidatable. Health < 1.3 means dangerously close.

• Vault positions show shares deposited in curated vaults (passive lending).

• Net value = supply + collateral + vaults - borrows.

Scans all Morpho chains by default (mainnet, base, arbitrum). Specify chain to narrow.

Use morpho_list_markets to find available PT markets. Use morpho_get_rate for live borrow rate on a specific market. Use spectra_get_portfolio for Spectra protocol positions (PT, YT, LP).

Get the current borrow rate and market state for a specific Morpho market. Provide the market's unique key (hex ID) and chain. Returns live borrow APY, supply APY, utilization, and liquidity — the data needed to calculate looping profitability. Use morpho_list_markets to discover market keys first.

Important: Rates are live as-of-query and change continuously based on utilization. When planning a looping strategy, verify rates are still favorable before executing. A profitable spread (fixed yield > borrow rate) can turn negative if borrow rates spike.

Use spectra_get_looping_strategy with these rates to calculate leveraged yield projections.

Find Morpho Blue lending markets by collateral type.

Two search modes:

1. PT collateral (default): Finds markets that accept Spectra/Pendle PT tokens as collateral. Use pt_symbol_filter to narrow (e.g., "USDC", "sUSDe"). Essential for looping strategies.

2. Any collateral: Use collateral_filter to search ANY Morpho market by collateral symbol (e.g., "ynRWAx", "wstETH", "WETH"). Finds IBT, LST, and other collateral markets that pt_symbol_filter would miss. IMPORTANT: Many yield-bearing tokens (IBTs) have Morpho markets using the raw token as collateral, NOT the PT wrapper.

When both filters are provided, collateral_filter takes precedence (broader search).

Enriched with Merkl campaign data: shows subsidized borrow/supply rates when Merkl campaigns are active on the market's collateral or loan assets. Subsidized borrow rates can be NEGATIVE (Merkl pays borrowers), dramatically improving looping economics.

Protocol context:

• LLTV = Liquidation Loan-to-Value. Threshold where liquidation CAN occur, NOT the safe operating level. Loop safely at ~90-95% of LLTV.

• High utilization (>90%) means limited borrowing capacity.

• Borrow rates are variable and can spike. Monitor when leveraged.

• Morpho chains: mainnet, base, arbitrum, katana.

Use spectra_get_looping_strategy for leveraged yield calculation. Use morpho_get_rate for live borrow APY on a specific market key. Use spectra_scan_opportunities for automated cross-chain looping discovery.

List Morpho vaults on a chain — discover where supply-side liquidity lives. Returns vault details including AUM, APY, fees, curator info, and market allocations.

Morpho vaults are curated lending strategies managed by curators who allocate deposits across lending markets. They are often (but not always) the primary source of supply-side liquidity for PT looping markets. EOA suppliers also exist.

Protocol context:

• Vault APY comes from lending yield on allocated markets, minus the curator's fee. High APY could indicate high borrow demand or could reflect temporary incentives.

• A vault's allocation breakdown shows which markets it supplies and how much capital is deployed to each. A vault allocating to a PT market directly funds the looping pool.

• Supply cap (when present) limits how much a vault will deploy to a given market. Uncapped allocations track demand; capped allocations create a ceiling.

• Not all vaults on a chain allocate to PT markets — many serve non-PT markets. Use morpho_get_market_suppliers with a specific market key to find who actually supplies it.

Use morpho_get_market_suppliers to see who supplies a specific market. Use morpho_list_markets to find available PT lending markets. Use spectra_get_looping_strategy to model leveraged yield after identifying supply liquidity.

Monitor liquidation risk across a curator's Morpho positions.

Computes health factor, liquidation price, distance-to-liquidation, and borrow rate for every borrowing position. Flags positions approaching danger zones.

Morpho has NO close factor — when health factor reaches 1.0, the ENTIRE position can be liquidated in one transaction. This makes distance-to-liquidation critical: a 14% distance means a 14% collateral price drop wipes the position completely.

Alert levels scaffold attention, not action — multiple signals may disagree:

• ok: position healthy, no immediate concern

• watch: distance below threshold or rate elevated — worth monitoring

• warning: health factor < 1.3 or distance dangerously low

• critical: health factor < 1.1 or distance < 5% — immediate attention needed

Use morpho_get_positions for raw position data without risk analysis. Use morpho_get_history to assess borrow rate stability over time. Use spectra_get_looping_strategy to model deleverage scenarios.

Perform a multi-signal health assessment of the IBT underlying a PT pool.

Checks conversion rate (on-chain ERC-4626), APR composition (organic vs incentive), pool balance ratio, APR magnitude, protocol recognition, and liquidity level.

Returns HEALTHY / CAUTION / WARNING verdict with per-check details.

A CAUTION flag means "proceed with awareness." A WARNING flag means "investigate before deploying." Output includes observation boundaries declaring what the snapshot cannot detect (rate trajectory, underlying governance, whether imbalance is transient). Pool imbalance checks surface competing explanations (demand vs withdrawal vs maturity).

Two modes:

1. Spectra mode (pt_address): Full analysis using Spectra API + on-chain checks.

2. Direct mode (ibt_address): Protocol-agnostic on-chain checks. Tries ERC-4626 convertToAssets(), falls back to Pendle SY exchangeRate(). Use for Pendle SY tokens, or any ERC-4626 vault not listed on Spectra. Runs: conversion rate + rate direction. Skips: APR, pool balance, liquidity.

If both are provided, pt_address takes priority (richer data from Spectra API).

Use spectra_get_pool_capacity to assess how much capital the pool can absorb. Use spectra_compare_yield for fixed-vs-variable rate analysis on the same PT.

Compare Pendle and Spectra yield opportunities side-by-side on the same chain. Auto-matches markets by underlying asset AND maturity proximity for head-to-head comparison.

Essential for MetaVault curators who can allocate to either protocol. Shows:

• Implied APY (fixed rate) comparison

• LP APY comparison (relevant for MetaVault allocation)

• Pool liquidity and TVL comparison

• Variable rate comparison

• Per-market winner analysis

• Maturity match quality (exact ≤7d, close ≤30d, loose ≤90d gap)

Only works on chains where both Spectra and Pendle are deployed: Ethereum, Optimism, BSC, Sonic, Base, Arbitrum, HyperEVM

Includes external Merkl campaign APR for both protocols when available.

Use pendle_list_markets for Pendle-only chain data. Use mv_scan_curator_opportunities for unified cross-protocol ranking with capital-aware sizing. Use spectra_scan_opportunities for Spectra-native capital-aware ranking.

Calibration oracle: what does "normal" look like for a market, pool, or IBT?

Produces statistical baselines from historical data — percentiles, anomaly thresholds, peer comparison, and assertion-ready language.

This is the bridge between perception (monitoring tools) and specification (security assertions like Phylax Credible Layer). The tool answers "what should the threshold be?" from observation, not theory.

For each metric (borrow APY, utilization, TVL, implied APY, etc.), returns:

• Normal range (5th-95th percentile from historical data)

• Current status (normal / elevated / anomalous)

• Anomaly threshold (conservative: min of 3-sigma and 2x historical max)

• Peer comparison (where this market sits among similar markets)

• Assertion hints (natural language threshold suggestions)

Supports Morpho markets (by market key), Pendle markets (by market address), and Spectra pools (by pool/PT address). Auto-detects target type from address format (64-char hex = Morpho, 40-char hex = Pendle/Spectra).

Use morpho_get_history or pendle_get_market_history for raw time-series. Use mv_check_ibt_health for single-point health snapshots. Use this tool when you need to CALIBRATE — set thresholds, compare to peers, or export knowledge about what normal looks like.

Aggregate multiple MetaVaults managed by a single curator into one portfolio view.

Three input modes (priority: explicit > label > address):

1. Explicit mode: metavault_addresses as a JSON array of {chain, address} pairs to aggregate specific vaults (machine-friendly).

2. Label mode: curator_label="Gami Labs" — resolves to the union of curator EOAs whose curator.name matches case-insensitively across chains. Solves the named-curator-multiple-EOAs case (e.g. Gami Labs has different EOAs on base vs flare).

3. Address mode: curator_address=0x... — scans all chains for MetaVaults where the curator's address matches the vault's curator.addresses array (machine-friendly when the EOA is known).

Returns:

• Total AUM across all vaults

• Blended APY (TVL-weighted)

• Projected annual fee revenue at the configured curator fee

• Concentration by underlying asset and by chain (suppressed for single-vault curators)

• Per-underlying rollup with expiry calendar (suppressed for single-underlying curators)

• Per-vault summary with position count and per-vault action items

• Cross-Vault Items: GENUINE cross-vault signals computed by aggregation (suppressed when no genuine signal fires — silent on clean is first-class)

Use spectra_get_curator_dashboard for deep-dive into a specific vault. Use morpho_monitor_risk for Morpho position health across the curator's address. Use spectra_stress_test_vault for withdrawal simulation on a specific vault.

Cross-protocol position map — see the whole wallet across Spectra, Pendle, Morpho, and governance.

Each protocol tool sees its own silo. This tool sees the contradictions BETWEEN silos. Calls all portfolio sources in parallel and composes a unified view with:

• Per-protocol position summaries with USD values

• Governance tokens (veSPECTRA on Base, vePENDLE if detectable)

• Cross-protocol totals with honest failure reporting

• Contradiction detection: lending vs fixed rate spreads, concentration risks, expiring positions across protocols, governance boost mismatches

• Entry path awareness for rebalancing opportunities

Does NOT replace per-protocol tools — use spectra_get_portfolio, pendle_get_portfolio, morpho_get_positions for deeper per-protocol analysis.

Use this as the FIRST call when analyzing a wallet. It answers "where am I?" before "what should I do?"

Get essential protocol mechanics for Spectra, Pendle, and Morpho — needed for correct reasoning. This server covers 3 protocols with 55 tools. This context tool teaches how they all work.

Use topic "pendle_morpho" first if you're unfamiliar with the multi-protocol scope — it explains all three protocols, their tools (spectra_*, pendle_*, morpho_*, mv_*), and when to use cross-protocol tools vs protocol-specific ones. IMPORTANT: MetaVaults (spectra_list_metavaults, spectra_model_metavault, spectra_get_curator_dashboard, spectra_stress_test_vault) are Spectra-specific curated vaults — don't miss them.

Use topic "workflow_routing" to learn which tools to call for a given goal (yield optimization, wallet analysis, YT arbitrage, curator strategies, etc.) and how they feed into each other. Recommended starting point for agents new to the tool set.

Use topic "pt_yt_mechanics" for how PT/YT splitting works on Spectra. Use topic "router_batching" for how Spectra Router affects pool activity interpretation. Use topic "deposit_path" for step-by-step entry mechanics (how to buy PT, mint YT, LP, loop). Use topic "glossary" for key term definitions (IBT, sw-prefix, LLTV, gauge, maturity value, APR vs APY, underlying, LP, ERC-4626, Curve StableSwap-NG, boost formula). Use topic "fees_and_costs" for protocol YT fees (Spectra 3%, Pendle 5%), reward basis (held vs notional), Merkl campaign types, and external points programs. Use topic "external_protocols" for the registry of non-Spectra protocols a MetaVault can hold via externalPositions[] (e.g. Avant one-week cooldown, Pendle instant LP exit): settlement windows, observation boundaries, mitigations. Call this before reasoning about withdraw speed or exit cost on positions that aren't in Spectra LP. Use topic "protocol_pulse" for LIVE cross-protocol vital signs (TVL, emissions, pool counts, expiring pools). Fetches real-time data — takes 5-15 seconds.

Available topics: pt_yt_mechanics, router_batching, position_analysis, looping, networks, deposit_path, glossary, fees_and_costs, pendle_morpho, workflow_routing, external_protocols, protocol_pulse Omit the topic parameter to get all topics at once.

Load the system's accumulated scars (corrective lessons), weighted by recency × reinforcement.

Use this in audit lenses to ground reasoning in what the system has been re-taught. Most useful for the Diverger lens: "what would consensus kill?" sharpens significantly when read against the system's own history of contradictions.

Weighting formula: weight = exp(-ageDays/30) × (1 + log2(1 + reinforceCount))

• 30-day recency halflife.

• Logarithmic dampening on reinforcement (1 = ×2, 3 = ×3, 7 = ×4).

• A scar reinforced 3+ times from 30+ days ago beats a one-time recent correction.

Scar source: feedback_*.md files in the memory directory. Each file's frontmatter:

name: description: type: feedback reinforces: # optional; absent = independent date: # optional; absent = falls back to file mtime

Default directory: ${HOME}/.claude/projects/${encoded-cwd}/memory Override via SCAR_DIR env var or scar_dir param.

Plan position rollovers for expiring MetaVault positions.

When a MetaVault position approaches maturity, the curator must: (1) identify the next pool, (2) estimate transition costs, (3) time the entry, (4) execute the rollover.

This tool automates steps 1-3 by scanning Spectra and Pendle for rollover candidates matching the expiring position's underlying asset, computing entry impact at the position's capital size, and ranking by effective APY.

Returns per expiring position: ranked list of rollover candidates with entry impact, yield gap (days of zero yield during transition), overlap window (if entering before old matures), and net effective APY after transition costs.

Use spectra_get_curator_dashboard to see which positions are approaching maturity. Use mv_scan_curator_opportunities for broader cross-protocol opportunity discovery. Use spectra_get_pool_capacity to assess depth at your capital size for specific candidates.

Scan all Spectra AND Pendle chains for the best yield opportunities, sized to your capital. Cross-protocol scanner designed for MetaVault curators who can allocate to either protocol.

Unlike spectra_scan_opportunities (Spectra-only), this tool includes Pendle markets with:

• Capital-aware price impact for BOTH protocols

• Maturity-aware cross-protocol matching (same underlying + similar expiry)

• Morpho looping analysis for Spectra PTs (Pendle looping in future phase)

• Unified ranking by effective APY across both protocols

• External Merkl campaign APR for both protocols (incentive programs beyond native yield)

• Protocol tags ([Spectra] vs [Pendle]) and cross-protocol match indicators

Unlike spectra_get_best_fixed_yields or pendle_list_markets, this tool computes effective APY at YOUR capital size — a high-APY pool with thin liquidity may be useless at your scale.

The ranking can disagree with spectra_scan_opportunities because it includes a different opportunity set (Pendle markets). This disagreement is intentional — both tools measure different things.

Use mv_compare_yield for detailed head-to-head on a specific chain. Use spectra_model_metavault to model blended Spectra+Pendle MetaVault allocation. Use spectra_get_curator_dashboard for operational monitoring of an existing MetaVault.

Find the best fixed-rate (implied APY) opportunities across all Pendle chains.

Scans all Pendle-supported chains and ranks markets by their implied APY — the fixed rate you lock in when buying PT at a discount. This is the Pendle equivalent of spectra_get_best_fixed_yields.

Unlike pendle_list_markets (which shows a single chain), this scans all chains at once and focuses on the PT buyer's perspective: which markets offer the highest fixed rate?

Unlike pendle_scan_opportunities (capital-aware), this is a quick raw-APY ranking without price impact analysis. Use it for initial screening, then drill into specific markets with pendle_get_market_details or size with pendle_scan_opportunities.

Pendle chains: Ethereum, Optimism, BSC, Sonic, Base, Arbitrum, Mantle, Berachain, HyperEVM, Corn

Calculate a leveraged fixed-yield strategy using Pendle PT + Morpho looping.

Strategy: Buy Pendle PT → use as Morpho collateral → borrow underlying → buy more PT → repeat. Each loop multiplies yield exposure.

Returns projected yields at different leverage levels (1x to max safe leverage), effective APY, risk parameters, borrow rate sensitivity, and break-even analysis.

Automatically fetches the live Morpho borrow rate and LLTV when a matching market exists.

NOTE: Looping requires a Morpho market that accepts the specific Pendle PT as collateral. Morpho markets for Pendle PTs exist primarily on Ethereum mainnet and some on Arbitrum.

The Pendle equivalent of spectra_get_looping_strategy.

Use pendle_get_market_details for full market info. Use pendle_scan_opportunities(include_looping=true) for cross-market looping rankings. Use morpho_list_markets to find available Morpho markets.

Analyze a Pendle market's capacity by computing price impact at increasing capital sizes.

Shows how price impact and effective APY degrade as capital grows, helping curators find the sweet spot (max capital with acceptable impact) and the exhaustion point (where APY collapses).

Uses Pendle's logit AMM model (conservative scalarRoot=50) which accounts for time-decay pricing. Near maturity, the AMM becomes more capital-efficient, so impact is lower than constant-product estimates.

This is the Pendle equivalent of spectra_get_pool_capacity.

Use pendle_get_market_details for full market information. Use pendle_scan_opportunities for capital-aware ranking across all markets.

Get detailed information about a specific Pendle market by address.

Returns: market name, PT/YT/SY/underlying addresses, implied APY (fixed rate), LP APY breakdown (swap fees + PENDLE incentives + boost), underlying variable APY, TVL, pool liquidity, 24h volume, pool reserves, maturity, and external Merkl campaigns.

This is the Pendle equivalent of spectra_get_pt_details. Use it to drill into a specific Pendle market after finding it via pendle_list_markets, mv_compare_yield, or mv_scan_curator_opportunities.

Use mv_check_ibt_health(ibt_address=SY_ADDRESS) to assess the underlying vault's health. Use mv_compare_yield to compare this market with Spectra equivalents.

Historical time-series data for a Pendle market.

Shows how implied APY, TVL, volume, PT/YT prices, and other metrics have moved over time. The first tool that answers "what happened?" not just "what is it now?"

Enables: trend analysis, yield stability assessment, anomaly detection, conviction building before entry. A flat APY with low stddev means predictable yield. A volatile APY with high stddev means the rate you see today may not persist.

Available fields: impliedApy, tvl, tradingVolume, ptPrice, ytPrice, baseApy, lpPrice, lpRewardApy, maxApy, pendleApy, swapFeeApy, syPrice, totalPt, totalSupply, totalSy, totalTvl, underlyingApy, underlyingInterestApy, underlyingRewardApy, voterApr, ytFloatingApy, lastEpochVotes

Use pendle_get_market_details for current market snapshot. Use pendle_list_markets to find market addresses.

View a wallet's Pendle positions across all chains (or a specific chain).

Shows PT, YT, and LP token balances with USD valuations for each Pendle market the wallet has positions in. Includes maturity dates, implied APY, LP APY, strategy inference, and expiry warnings.

This is the Pendle equivalent of spectra_get_portfolio.

Use pendle_get_market_details to drill into a specific market. Use mv_plan_rollover to plan rollovers for expiring positions. Use spectra_get_portfolio for Spectra positions.

Get Pendle protocol-wide statistics: total TVL, market count, liquidity, and volume across all Pendle-supported chains.

Shows per-chain breakdown and aggregate metrics. Includes:

• Active market count and TVL per chain

• Total pool liquidity and 24h volume

• Average implied APY and LP APY

• Chain overlap with Spectra (expansion opportunities)

The Pendle equivalent of spectra_get_protocol_stats.

Use pendle_list_markets for detailed market-level data. Use mv_scan_curator_opportunities for cross-protocol ranking.

Show the yield curve (term structure) for a given underlying asset across Pendle chains.

Fetches all active Pendle markets matching the underlying (e.g., "USDC", "ETH", "stETH"), sorts by maturity, and displays implied APY at each point on the curve.

This is the fixed-income view: "What rate can I lock for 30 days vs 90 days vs 180 days?" Helps curators spot term premium anomalies, compare cross-chain rates, and choose maturities.

The Pendle equivalent of spectra_get_yield_curve.

Use pendle_get_market_details to drill into a specific maturity. Use pendle_get_market_capacity to check depth at your capital size. Use mv_compare_yield for Spectra vs Pendle comparison on the same underlying.

Scan Pendle chains for markets approaching maturity.

Groups results by urgency:

• CRITICAL (≤7d): Immediate action required — redeem or rollover

• WARNING (≤14d): Plan rollover within days

• ALERT (≤threshold): Monitor and prepare

This is the Pendle equivalent of spectra_list_expiring_pools. Useful for:

• Portfolio managers who need to plan rollovers

• Curators monitoring MetaVault positions that include Pendle PTs

• Traders looking for near-maturity convergence plays

Use pendle_get_market_details for full market info on an expiring market. Use mv_plan_rollover to plan rollovers for MetaVault positions. Use pendle_get_yield_curve to find replacement maturities.

List active Pendle markets on a given chain, or scan all Pendle-supported chains. Returns: market name, implied APY (fixed rate), LP APY, TVL (underlying deposited), liquidity (AMM depth), maturity, and token addresses.

Pendle is a competing/complementary yield tokenization protocol. Like Spectra, it splits yield-bearing tokens into PT (principal) and YT (yield). Key differences:

• Pendle uses its own AMM (not Curve) with time-decay pricing

• Pendle has PENDLE token incentives on LP positions

• Pendle markets exist on chains where Spectra may not be deployed yet

This data is essential for curators building cross-protocol MetaVaults. A MetaVault can integrate Pendle PTs alongside Spectra PTs, allocating to whichever protocol offers better rates for a given underlying + maturity.

Pendle-supported chains: Ethereum (mainnet), Optimism (optimism), BSC (bsc), Sonic (sonic), Base (base), Arbitrum (arbitrum), Mantle (mantle), Berachain (berachain), HyperEVM (hyperevm), Corn (corn) Chains with Spectra overlap: mainnet, optimism, bsc, sonic, base, arbitrum, hyperevm Pendle-only chains (Spectra not deployed): mantle, berachain, corn

Includes external Merkl campaign APR when available (LP, YT, and SY incentive programs). Merkl campaigns are fetched best-effort per chain and shown alongside native PENDLE incentives.

Use mv_compare_yield to do a head-to-head comparison on a specific underlying. Use mv_scan_curator_opportunities for unified cross-protocol ranking with capital-aware sizing. Use spectra_scan_opportunities for Spectra-native opportunity ranking.

Estimate expected output, price impact, and effective APY for a Pendle PT trade.

Uses the Pendle logit AMM model to estimate trade outcomes. Shows:

• Expected output amount and effective rate

• Price impact at your trade size

• Effective APY after accounting for entry cost

• Minimum output with slippage tolerance

Side:

• "buy": Spend underlying/SY to get PT (lock in fixed rate)

• "sell": Sell PT for underlying/SY (exit fixed position)

The Pendle equivalent of spectra_quote_trade.

Use pendle_get_market_capacity for a multi-size impact curve. Use pendle_get_market_details for full market information.

Scan all Pendle chains for the best yield opportunities, sized to your capital.

This is the Pendle equivalent of spectra_scan_opportunities. Unlike pendle_get_best_fixed_yields (raw APY ranking), this tool computes:

• Entry price impact at YOUR capital size using Pendle's logit AMM model

• Effective APY after amortizing entry cost over days to maturity

• Pool capacity (max capital before impact exceeds threshold)

• Morpho looping availability for Pendle PTs on Morpho-capable chains

• External Merkl campaign incentives

The ranking reflects what you can actually EARN, not just what the protocol advertises.

For cross-protocol scanning (Spectra + Pendle together), use mv_scan_curator_opportunities. For Spectra-only scanning, use spectra_scan_opportunities.

Scan Pendle markets for YT (Yield Token) mispricing opportunities.

Compares the underlying's variable APY against the implied rate from the PT/YT market price. When these diverge, a spread exists:

• Positive spread (Underlying APY > Implied): YT is underpriced — buy YT

• Negative spread (Underlying APY < Implied): YT is overpriced — sell YT

Unlike Spectra (where YT trades indirectly via Router flash-mint/redeem), Pendle YT trades directly on the Pendle AMM, making execution simpler:

• Buy YT: swap SY → YT on Pendle AMM

• Sell YT: swap YT → SY on Pendle AMM

This is the Pendle equivalent of spectra_scan_yt_arbitrage.

Use pendle_get_market_details for detailed info on a specific opportunity. Use mv_compare_yield for cross-protocol comparison on the same underlying.

Simulate how a Pendle PT trade would change a wallet's portfolio.

Shows before/after comparison:

• Existing Pendle positions on the target chain

• New position from the simulated trade

• Blended APY across all positions

• Concentration analysis

Does NOT execute any transaction — purely informational.

The Pendle equivalent of spectra_simulate_trade.

Use pendle_quote_trade for a detailed trade quote first. Use pendle_get_portfolio to see full current portfolio.

Compare Spectra's fixed yield (via PT) against the variable yield of the underlying interest-bearing token. Helps users decide if locking in a fixed rate is worthwhile versus staying in the variable-rate position.

Protocol context:

• Fixed rate is labeled "implied APY" (annualized, compounded). Variable rate is labeled "IBT APR" (not compounded). LP yield is labeled "LP APY". Each is labeled at point of use.

• Entry cost (price impact) is amortized over days to maturity.

• LP alternative: providing liquidity earns trading fees + SPECTRA gauge emissions.

Output surfaces competing interpretations when the data is ambiguous — e.g., positive raw spread but negative effective spread after entry cost, or incentive-dominated variable rate.

Use spectra_get_looping_strategy to lever up the fixed yield via Morpho. Use spectra_get_portfolio to check your current positions. Use spectra_scan_opportunities for multi-chain comparison.

Scan all pools on a chain (or all chains) for a given address's activity. Returns per-pool breakdown and cross-pool aggregates. Useful for discovering multi-pool strategies without making N manual spectra_get_pool_activity calls.

When investigating a wallet that operates across multiple pools (e.g., a curator or yield farmer diversifying across maturities), this tool reveals the full scope of their on-chain activity in one call.

Each pool's activity is summarized with type breakdown and total volume. Cross-pool totals show the address's aggregate engagement with Spectra.

For deep per-pool analysis (cycle detection, flow accounting, contract detection), use spectra_get_pool_activity with the address parameter on the specific pool of interest. Use spectra_get_portfolio to see current holdings across all pools.

Includes an Observation Coverage section that quantifies blind spots: which pools were scanned, what event types are visible vs invisible (standalone mints, yield claims, and non-Spectra operations are never visible here), and whether activity is concentrated on one chain. Position sizing should assume this scan is incomplete, not comprehensive.

Find the best fixed-rate yield opportunities across all Spectra chains. Scans all supported networks and returns the top opportunities ranked by implied APY. Filters by asset type if specified.

Important: This ranks by raw implied APY without considering your capital size or pool liquidity. These rankings will often disagree with spectra_scan_opportunities (which ranks by effective APY after entry cost). That disagreement is intentional -- raw APY reflects the pool's headline rate while effective APY reflects what you actually capture at your capital size. Neither ranking is "correct" -- they measure different things. Use both to develop conviction about which pools genuinely serve your strategy.

Operational dashboard for MetaVault curators.

Aggregates vault health, position status, depositor flows, fee revenue estimates, and actionable alerts into a single view. Designed for curators managing live MetaVaults who need a quick operational overview.

Returns:

• Vault health: TVL with unallocated ratio (undeployed capital AFTER subtracting external positions — shown when >5%), Status label for non-VISIBLE vaults, live APY with optional 30d avg suffix and APY composition (base vs incentives), share price

• APY 4-number breakdown when live-vs-30d delta ≥ 0.5pp: shows base+incentive decomposition for both snapshots WITHOUT asserting causality (agents draw their own conclusions from the numbers)

• Position status: each active PT position with maturity countdown, APY, and size. Positions approaching maturity are flagged (!!!=14d, !!=30d)

• External Positions: value held OUTSIDE Spectra LP structure (avant avUSDx-burn redemption-in-flight, pendle LP on other protocols). Rendered per-protocol with graceful fallback for unknown protocols

• Capital State decomposition line: when ≥1 of {expired-stuck, external} buckets populated, emits a single line showing deployed/expired-stuck/ external/unallocated as % of TVL

• Depositor flows: epoch-by-epoch net inflows/outflows with trend analysis

• Fee revenue: estimated annual curator fee revenue (snapshot projection)

• Action items: auto-generated alerts including [UNALLOC] (softened when external capital coexists), [STATUS] (HIDDEN vaults), [PENDLE-EXT URGENT/UPCOMING/EXPIRED] (external Pendle maturity), [EXPIRED] / [URGENT] / [SOON] / [UPCOMING] (Spectra LP maturity), [OUTFLOWS], [BRIDGE], [INCENTIVE], [PENDLE ROLLOVER]

Pool allocations show each position as a % of total vault TVL (e.g., "37.1% | $236K"), sorted by size, with protocol tags ([Spectra]/[Pendle]/[Unknown]) on each position. Unallocated liquidity is shown separately (and excludes capital deployed in external positions — labeled as "unallocated" to distinguish from "idle"). When the API doesn't provide LP balance data for a position, it shows "?%".

Cross-chain positions: MetaVault positions may live on a different chain than the MetaVault itself (e.g., Base MetaVault → Avalanche pools via CCTP bridge). Pool addresses in positions are on the position's chain, not the MetaVault's home chain.

Epoch flows: Derived from asset snapshots and rate changes. Yield accrual is estimated from share rate deltas — actual yield may differ. Use share price trend to corroborate.

Requires chain + metavault_address. Use spectra_list_metavaults to discover addresses. Use spectra_model_metavault for leverage modeling after reviewing the dashboard. Use spectra_get_pool_activity on specific pool addresses for trading pattern analysis. Use spectra_get_address_activity on the curator's EOA for cross-pool curator activity.

When verify_externals=true (off by default), each avant external position is probed on Avalanche's RequestsManager — confirms state (CREATED/COMPLETED/CANCELLED), provider attribution, on-chain amount (with PPM tolerance for API rounding), global counter, and pause flag. A [chain-truth ✓/⚠/✗] line is appended under each avant position. Per-order failures degrade gracefully and never poison sibling positions or block the dashboard. Pendle externals are NOT yet probed in this slice.

Full veSPECTRA governance dashboard: gauge vote distribution, voting APRs, bribe incentives, SPECTRA emissions per pool, and Merkl campaign health.

Shows where veSPECTRA holders direct their votes, what rewards they earn for voting, and how SPECTRA emissions are distributed across pools. Essential for:

• Deciding where to direct veSPECTRA votes for maximum return

• Finding pools with active bribe markets (voting incentives)

• Understanding emission concentration and governance dynamics

• Evaluating bribe efficiency ($ per vote)

• Detecting broken emission pipelines (votes directing SPECTRA to pools where no Merkl campaign exists to distribute them)

Each gauge is cross-referenced against live Merkl campaigns: ✅ = Merkl campaign active at the gauge's pool address (emissions flowing) ⚠ = Merkl campaign exists but targets a different pool address (likely stale — gauge rolled to a successor pool but the campaign wasn't updated) ❌ = No campaign found (emissions allocated by governance but not distributed)

The ⚠ stale detection uses fuzzy symbol matching: if the gauge symbol (e.g., "yvvbUSDC") appears in a Merkl campaign name containing "Spectra" but the campaign targets a different address, the campaign likely belongs to a matured predecessor pool. This catches the common failure mode where pools roll to new maturities but Merkl campaigns lag behind.

The voting APR is what veSPECTRA holders earn by directing votes to a gauge: voting APR = (voting rewards + swap fees) / vote value

Bribe efficiency = total voting rewards / total votes (in $). Higher efficiency = more reward per unit of voting power directed.

Use spectra_get_ve_info for your personal boost calculation. Use spectra_list_pools to see the pools behind these gauges. Use spectra_list_expiring_pools to check gauge status for expiring pools.

Calculate a leveraged fixed-yield strategy using Spectra PT + Morpho looping.

Strategy: Deposit asset -> mint PT on Spectra -> use PT as collateral on Morpho -> borrow underlying -> deposit again -> repeat. Each loop multiplies yield exposure.

Returns projected yields at different leverage levels (1x to max safe leverage), effective APY, and risk parameters.

Automatically fetches the live Morpho borrow rate and LLTV when a matching market exists. You can still override morpho_ltv and borrow_rate manually if needed.

NOTE: Looping requires a Morpho market that accepts the specific PT as collateral.

Risk context:

• Borrow rates are variable. A 5% spread (7% yield - 2% borrow) can turn negative if borrow rates spike above your fixed yield. Monitor rates in Morpho.

• Higher leverage amplifies both returns and liquidation risk. Consider keeping 1-2 loops below maximum for safety buffer.

• Entry cost (price impact) compounds across loops — each iteration faces degraded effective pool liquidity.

Use morpho_list_markets to find available Morpho markets. Use spectra_scan_opportunities to discover the best looping opportunities across all chains with capital-aware sizing.

Fetch historical on-chain activity directly from event logs via eth_getLogs. Use this when the API-based spectra_get_pool_activity returns empty or incomplete data (the API only stores a limited time window of recent transactions).

Supports TWO contract types:

1. Curve StableSwap-NG pool (pool_address): TokenExchange, AddLiquidity, RemoveLiquidity

2. Spectra PrincipalToken vault (pt_address): Mint (deposit→PT+YT), Redeem (burn PT→IBT), YieldClaimed

Provide pool_address, pt_address, or both. When both are provided, events from both contracts are fetched in parallel, merged, and sorted by block number.

Returns raw token amounts (not USD values — USD conversion is not available from on-chain data alone).

The rpc_url parameter lets you supply an RPC endpoint for any chain, including chains without hardcoded RPCs (e.g., Katana, Monad). If omitted, falls back to the server's default public RPC for the chain (if available).

Block range strategy:

• Specify from_block/to_block for exact ranges

• Or specify lookback_hours to scan the last N hours (converted to blocks using estimated block times — approximate, not exact)

• Default: last ~24 hours if no range is specified

Limitations:

• No USD values (only raw token amounts in native decimals)

• Block timestamps are fetched for first/last block only (time range display)

• Public RPCs may rate-limit large scans; use a premium RPC for deep history

• Maximum 500,000 blocks per request (to prevent timeout)

Use spectra_get_pool_activity for recent data with USD values and rich analysis. Use this tool for historical data beyond the API's retention window.

Get recent trade and liquidity activity for a specific Spectra pool. Returns individual transactions: buys, sells, and liquidity adds/removes with USD values, timestamps, and tx hashes.

Pool activity shows only the Curve pool's perspective (IBT ↔ PT swaps and LP events). The Spectra Router batches operations atomically, so any single pool event may be one step of a multi-step strategy. There is no BUY_YT or SELL_YT event type — the pool never touches YT directly. Use mv_get_protocol_context for the full mechanics of how Router batching maps to pool activity types.

Protocol mechanics that affect how activity appears:

• BUY_PT and SELL_PT are Curve pool swaps between IBT and PT.

• There is NO "BUY_YT" or "SELL_YT" type. The pool never touches YT directly.

• YT selling via the Router's flash-redeem internally buys PT from the pool to pair with YT for redemption — so YT sells show up as BUY_PT in the activity log.

• A standalone mint (deposit IBT → PT+YT) does NOT appear in pool activity. However, the Router can batch a mint + LP add in one atomic execute() call. The minted PT + remaining IBT enter the pool as AMM_ADD_LIQUIDITY while the minted YT goes directly to the user's wallet. So AMM_ADD_LIQUIDITY events may ALSO represent YT acquisition — the YT minting is invisible in pool data.

• The Router can also flash-mint atomically: flash-borrow IBT → mint PT+YT → sell PT on the pool → user tops up the shortfall → user receives YT. This shows up as SELL_PT but the user's net action is acquiring YT, not selling PT.

• AMM_REMOVE_LIQUIDITY returns IBT + PT from the pool. Users often follow up by selling the PT (SELL_PT) to recover capital, completing a mint→LP→remove→sell loop that nets them YT at the cost of the PT discount (~1 - ptPrice).

Key principle: any pool event type can be one step of a multi-step Router operation. Do not assume SELL_PT means "user is bearish on PT" or AMM_ADD_LIQUIDITY means "user is providing liquidity for yield." Always cross-reference with spectra_get_portfolio to see what the address actually holds (PT, YT, LP balances) — the holdings reveal the true strategy better than the activity log alone.

Analysis tips — IMPORTANT: each observation below has multiple valid interpretations. The tool output now presents these as competing branches. Do not collapse to one interpretation without cross-referencing spectra_get_portfolio and other data sources.

• High SELL_PT count: could be flash-mint YT accumulation (check YT balance >> PT) OR simple PT liquidation OR one leg of cross-protocol arb. Portfolio resolves this.

• BUY_PT events: could be fixed-rate accumulation OR flash-redeem YT selling (check if YT balance dropped). These predict opposite future behavior.

• Paired ADD/REMOVE liquidity: could be LP cycling in a mint loop OR fee harvesting OR rebalancing. The intent is not observable from pool activity alone.

• Large volume vs small holdings: could be capital recycling (looping) OR completed round-trip (entered and exited) OR funds moved to another venue.

Output includes an Address Concentration section with full addresses and per-address type breakdowns. Use spectra_get_portfolio on those addresses to see their PT, YT, and LP balances. Most analysis can be done without a block explorer — use spectra_get_portfolio on addresses from Address Concentration, and spectra_compare_yield or spectra_get_pt_details for rate context.

Address isolation mode: When you provide an 'address' parameter, the tool filters to that address only, sorts chronologically (oldest first), and adds:

• Sequence Analysis: detects repeating action cycles (e.g., ADD→REMOVE→SELL repeated 8×). Presents COMPETING INTERPRETATION BRANCHES (A/B/C) that predict different future behavior. Small repetition counts (≤5) are flagged as statistically insufficient for extrapolation. CRITICAL: do NOT collapse these branches into a single narrative without external evidence from spectra_get_portfolio or other tools. The branches exist as friction against premature pattern-matching — the tension between them IS the information.

• Flow Accounting: cross-references portfolio data to show PT/YT flow reconciliation. When position shape is observable (e.g., YT-only, PT-only, fully exited), presents competing hypotheses for WHY the position looks that way. Each hypothesis predicts different future behavior. Do not select one without additional evidence.

• Capital Efficiency: compares total activity volume against the address's throughput, flagging high ratios that indicate capital recycling (looping) vs accumulation.

• If the address shows high-frequency activity (>10 txns), consider checking whether it is a contract (programmatic execution via Router execute()) vs an EOA (manual/scripted). Contracts execute atomically; EOAs submit separate transactions. This distinction affects whether apparent "sequences" are truly sequential or batched.

• Contract Detection: checks whether the address is a contract or EOA via on-chain eth_getCode. Contracts execute atomically; EOAs submit sequential transactions.

• Pool Impact: flags when SELL_PT or BUY_PT volume is significant relative to pool liquidity, indicating potential market impact on implied APY.

• Gas Estimates: estimates total gas cost from transaction count using chain-specific gas heuristics. Shows gas as percentage of activity volume and position value.

• Pool Context: fetches pool liquidity and implied APY for baseline context.

• Observation Coverage: quantifies the blind spots of this analysis. Shows: (1) Value coverage — what % of the position is explained by observable activity. (2) Temporal coverage — active days vs dark periods with no observable events. (3) Data source coverage — which of the available data sources were consulted. CRITICAL: coverage metrics bound the domain of validity for ALL interpretations above. If value coverage is low (<50%), the competing interpretation branches are based on a minority of the address's actual behavior. Position sizing should reflect the coverage level, not the confidence of the best-fitting interpretation.

For multi-pool activity scanning, use spectra_get_address_activity to find all pools an address has interacted with in a single call.

Analyze a pool's capacity by quoting PT trades at increasing capital sizes.

Shows how price impact and effective APY degrade as capital grows, helping curators and large deployers find the sweet spot (max capital with acceptable impact) and the exhaustion point (where APY collapses).

Two modes: "pt_buy" (default): Measures PT swap impact via Curve get_dy(). Shows how much capital can be deployed as a directional PT buyer before slippage degrades APY. "lp_add": Measures LP deposit impact. LP deposits add liquidity to BOTH sides of the pool, deepening it rather than consuming it. Impact is near-zero for balanced deposits. Shows pool share concentration and post-deposit pool depth. USE THIS MODE for MetaVault curator capacity analysis — curators deploy as LP.

Each tier is quoted independently (not cumulative). Real execution across multiple txns would face additional impact from pool state changes.

Output surfaces a capacity framing note: pt_buy mode measures directional swap impact, but MetaVault curators deploy as LP where entry impact is near-zero and the constraint is pool share concentration. Use lp_add mode for curator capacity analysis.

On-chain quotes use the actual Curve StableSwap-NG amplification parameter. Set use_on_chain=false for math-only estimates (faster, more conservative).

Use spectra_quote_trade for a single exact quote at a specific amount. Use spectra_scan_opportunities for capital-aware ranking across all pools. Use mv_check_ibt_health to verify the underlying IBT before deploying.

Get historical trading volume for a specific Spectra pool. Returns timestamped buy/sell volume in USD. Use spectra_list_pools first to find pool addresses. Useful for assessing pool activity and liquidity depth before entering a position.

Context: Volume alone doesn't indicate capital efficiency — $1M volume in a $5M liquidity pool is very different from $1M in a $500K pool. Combine volume data with pool liquidity (from spectra_list_pools or spectra_get_pt_details) to assess real trading conditions.

Output includes volume/liquidity ratio analysis when pool data is available. For individual transaction details and whale activity, use spectra_get_pool_activity instead. Use spectra_quote_trade to estimate price impact for a specific trade size.

Get wallet positions on Spectra for a specific address. Returns PT, YT, and LP balances with USD values, claimable yield, and current rates. Queries a single chain or all chains. Use this to understand what a wallet currently holds on Spectra.

Also fetches unclaimed Merkl rewards (SPECTRA gauge emissions and other incentive programs) per position. Merkl rewards are best-effort — if the Merkl API is unavailable, the portfolio still displays without reward data.

Protocol context:

• Depositing IBT always mints BOTH PT and YT in equal amounts. If a wallet holds YT but no PT, it sold or LPed its PT. If it holds PT but no YT, it sold its YT.

• PT + YT = 1 underlying at maturity. This identity is fundamental to all strategies.

• Balance ratios are the key signal. Output shows Position Shape (e.g., "YT/PT 4:1") so you can reason about what the holder's position implies given the mechanics above.

• When investigating a strategy, ALWAYS cross-reference portfolio with spectra_get_pool_activity. Activity shows the HOW (transaction patterns), portfolio shows the WHAT (resulting position). Neither alone tells the full story.

• Strategies often span multiple wallets. If spectra_get_pool_activity shows concentrated activity from several addresses, check each one to build the full picture.

• For activity analysis, use spectra_get_pool_activity with the address parameter — it will automatically cross-reference portfolio data and provide flow accounting, contract detection, gas estimates, and pool impact analysis.

• Use spectra_get_address_activity to scan all pools for an address's activity in one call.

Get Spectra protocol-wide statistics: SPECTRA token supply, circulating supply, current weekly emissions, rebase formula, and general protocol info. Use this for questions about SPECTRA tokenomics or protocol health.

Protocol context:

• Rebase distributes additional SPECTRA to veSPECTRA holders. The formula is highly non-linear: (veSPECTRA/totalSPECTRA)^3. At 10% lock rate, rebase captures ~0.1% of emissions. At 50% lock rate, rebase captures ~12.5%. This incentivizes high ve participation.

• Weekly emissions decay exponentially and eventually stabilize.

• Gauge emissions boost LP APY across all pools (see LP APY breakdown in pool tools).

Use spectra_get_ve_info for live veSPECTRA data and boost calculations.

Get detailed information about a specific Spectra Principal Token (PT). Returns: maturity date, TVL, implied APY, PT/YT prices, pool liquidity, LP APY breakdown, underlying asset info, IBT protocol, yield leverage, pool reserves (IBT/PT amounts), maturity redemption value, points program multipliers, asset tags, and base IBT info.

Protocol context:

• PT trades at a discount to its underlying (the discount IS the fixed yield). At maturity, PT redeems for the maturityValue shown (may differ from 1:1).

• PT + YT = 1 underlying at maturity. YT price = 1 - PT price (in underlying terms).

• YT leverage shows how much yield exposure 1 unit of YT provides relative to holding the underlying directly. Higher leverage = more amplified yield exposure.

• IBT APR breakdown shows organic yield vs external incentive programs. High APR from incentives alone may not be sustainable.

Includes external Merkl campaign APR when available.

Output surfaces conditional competing interpretations when data is ambiguous — e.g., PT above par, skewed reserves, high APY with thin liquidity, or incentive-dominated APR. These appear only when triggered by the specific data returned.

Use spectra_compare_yield to compare fixed vs. variable rates. Use spectra_get_looping_strategy to calculate leveraged fixed yield via Morpho. Use spectra_get_portfolio to check wallet holdings. Use spectra_get_pool_activity to see trading patterns on this pool.

Get live veSPECTRA governance token information and compute boost scenarios.

Reads the current veSPECTRA total supply from Base chain on-chain, and given your balance + a specific pool, computes your exact boost multiplier.

The Spectra boost formula: B = min(2.5, 1.5 * (v/V) * (D/d) + 1) v = your veSPECTRA balance V = total veSPECTRA supply (read live from Base) D = pool TVL d = your deposit size Full 2.5x boost when: v/V >= d/D (your share of votes >= your share of pool)

Useful for understanding how much veSPECTRA you need for max boost in a given pool at a given deposit size.

Show the yield curve (term structure) for a given underlying asset across all chains.

Fetches all active Spectra PTs matching the underlying (e.g., "USDC", "ETH"), sorts by maturity, and displays implied APY at each point on the curve.

This is the fixed-income view: "What rate can I lock for 30 days vs 90 days vs 180 days?" Helps curators spot term premium anomalies, compare cross-chain rates at similar maturities, and choose optimal maturity targets.

Handles symbol variants automatically (USDC.e, WETH, wstETH → normalized).

Use spectra_get_pt_details or mv_check_ibt_health to drill into a specific maturity. Use spectra_get_pool_capacity to check depth at your capital size. Use spectra_compare_yield for fixed-vs-variable analysis on a specific PT.

List all blockchain networks supported by Spectra Finance. Use this as a starting point to discover what's available.

Not all chains have identical feature coverage. Morpho looping markets currently exist on mainnet, base, arbitrum, and katana. veSPECTRA governance lives on Base.

Scan all Spectra chains for pools approaching maturity.

Returns pools expiring within the specified threshold (default 21 days / 3 weeks), grouped by urgency level. Designed for operators who need lead time to:

• Create follow-up pools with new maturities

• Submit gauge proposals for successor pools

• Plan LP migration and rollover strategies

• Coordinate with IBT protocol teams

Each result includes the PT address, IBT address, chain ID, underlying asset, TVL, and current implied APY — everything needed to plan the successor pool.

Automatically cross-references each expiring pool's IBT against all active pools to flag whether a successor pool (same IBT, later maturity) already exists or needs to be created.

Gauge status is fetched from the governance voting-incentives API. A pool address present in that endpoint has a gauge (even if it currently has 0 votes / 0 emissions). Gauge API failure is best-effort — gauge status shows as unknown, does not block results.

Per-pool readiness assessment combines successor status, gauge status, and timing: OK: Successor deployed with gauge and seeded CAUTION: Successor exists but missing gauge or low TVL; or no successor but >7d runway WARNING: No successor and ≤7d; or successor without gauge and ≤14d

Urgency (time-based) and readiness (action-based) are independent dimensions. A pool can be ALERT urgency (21d runway) but WARNING readiness (no successor at all). The Operator Checklist section groups required actions by type:

• Deploy successor pool: IBTs with no active successor

• Submit gauge proposal: successors that exist but lack a gauge

• Ready for migration: successors with gauge and adequate TVL

Urgency levels: CRITICAL (≤7 days): Immediate action required WARNING (≤14 days): Start preparations now ALERT (≤21+ days): Plan ahead

Set include_expired=true to also show recently matured pools (if the API returns them). By default only active (non-expired) pools are shown.

Use mv_plan_rollover on a specific MetaVault for automated rollover candidate discovery. Use spectra_get_yield_curve to see what maturities already exist for the same underlying. Use spectra_list_pools to check if a successor pool has already been created.

List live MetaVaults from the Spectra API.

MetaVaults are ERC-7540 curated vaults that automate LP rollover and compound YT yield back into LP positions. They are managed by curators who earn performance fees on depositor yield.

Returns all MetaVaults with:

• Curator info, TVL (with unallocated ratio when >5% undeployed, computed AFTER subtracting external positions so avant/pendle externals aren't mislabeled as idle)

• Live APY breakdown + 30d avg (when available)

• Active Spectra LP positions (PT markets the vault is deployed in)

• External Positions: value held OUTSIDE Spectra LP (avant avUSDx-burn redemption-in-flight, pendle LP on other protocols). Surfaced per-protocol with graceful fallback for unknown protocols. This field is UNDOCUMENTED by Spectra — shape is inferred from observed data and may change.

• Cross-chain module whitelist (remote.{chainId}.modules) showing enabled protocols per foreign chain (e.g., avant/parallel on Avalanche)

• Status flag (VISIBLE / HIDDEN) — HIDDEN vaults are surfaced here but filtered out in the Spectra UI; the compact listing does not prefix the name with a status label (detail view only)

• Underlying asset details

• Vault flows: epoch-by-epoch deposit/withdrawal analysis

• Bridge transactions: cross-chain CCTP transfers

• Epoch history (rate snapshots)

Use this tool to discover which MetaVaults are live, then pass the address to spectra_model_metavault for detailed strategy modeling or spectra_get_curator_dashboard for the full operational view with action items.

To investigate curator activity (LP adds/removes, rebalancing), use spectra_get_address_activity on the curator's EOA address — MetaVault operations go through the Spectra Router, so the vault contract address won't appear in pool activity data.

When verify_onchain=true (off by default), each MetaVault gets a compact chain-truth summary line probed via the same engine that powers spectra_get_curator_dashboard. Useful for cross-chain triage when the dashboard isn't pre-rendered. Chain-read failures degrade to a [chain-truth ✗] line per MV — they NEVER abort the rest of the list. Concurrency is capped at 6 simultaneous reads to avoid RPC rate limits.

List all active Spectra pools on a given chain. Returns a summary of each pool including: asset name, maturity, TVL, implied APY, LP APY, pool liquidity, pool reserves (IBT/PT amounts with ratio), IBT APR breakdown (organic vs incentive yield), maturity redemption value, points multipliers, and asset tags.

Metric definitions used across all Spectra tools:

• PT TVL = value of underlying deposited to mint PTs (pt.tvl in API)

• Liquidity = AMM pool depth (IBT + PT both sides of the Curve pool, pool.liquidity in API)

• Implied APY = annualized fixed rate from buying PT at discount

• IBT APR = variable rate on the underlying vault (labeled APR, not compounded)

Each pool is a Curve StableSwap-NG AMM pair of IBT and PT. LP APY is the yield from providing liquidity to the pool (fees + gauge emissions).

Set include_expired=true to also show recently matured pools (if the API returns them). By default only active (non-expired) pools are shown.

Includes external Merkl campaign APR when available. Output surfaces conditional competing interpretations when data is ambiguous (e.g., high APY with thin liquidity).

For multi-chain discovery, use spectra_get_best_fixed_yields (raw APY ranking) or spectra_scan_opportunities (capital-aware with price impact and looping analysis). Use spectra_get_pool_activity on a specific pool to see recent trading patterns.

Model a MetaVault "double loop" strategy for curators.

MetaVaults are ERC-7540 curated vaults that automate LP rollover and compound YT yield back into LP positions. This tool models the economics of leveraging MetaVault shares as collateral on Morpho (or similar lending markets).

Two modes:

1. Live mode: Provide chain + metavault_address to auto-populate base_apy from the live MetaVault API. All other params can be overridden.

2. Manual mode: Provide base_apy directly for hypothetical modeling.

The "double loop": Layer 1 (inside vault): YT yield → LP tokens (compounding loop, managed by curator) Layer 2 (on top): MV shares → Morpho collateral → borrow → deposit back (leverage loop)

Because YT compounding raises the base yield, leverage multiplies a higher base — creating a "double loop premium" over raw PT looping.

Dual Morpho Market Strategy: Curators should create TWO Morpho markets for maximum flywheel effect: Market A (PT / underlying): For external users to loop PT. Drives pool volume & LP fees. Market B (MV shares / underlying): For the curator to loop vault shares. Amplifies own capital. These markets reinforce each other — PT demand deepens the pool, deeper pool attracts more loopers, and the curator earns fees on all external deposits flowing through the vault.

Curator economics: The curator EARNS the performance fee on external deposits — this is revenue for managing the vault (rolling positions, compounding YT, maintaining allocations).

Blended allocation: Supports modeling MetaVaults that allocate across both Spectra and Pendle LP positions via pendle_allocation_pct and pendle_lp_apy parameters. Computes blended base APY and warns about manual Pendle rollover requirements.

Estimate expected output, price impact, and minimum output for a PT trade. Automatically uses on-chain Curve get_dy() for exact quotes when a public RPC is available for the chain. Falls back to a conservative constant-product math estimate if on-chain quoting fails.

Side: "buy" = spend underlying/IBT to buy PT (e.g. spend USDC-worth to get PT) "sell" = sell PT to receive underlying/IBT

This tool only quotes PT trades on the Curve AMM pool. YT does not trade on the pool directly — YT is acquired by minting (deposit IBT to get PT+YT) or sold via flash-redeem. To estimate YT value: YT price = 1 - PT price in underlying terms.

Returns: expected output amount, spot & effective rates, price impact, and minOut at the specified slippage tolerance. Also includes pool context: IBT/PT reserves with ratio, and IBT APR composition (organic vs incentive yield). The output indicates whether the quote came from on-chain (exact) or math estimate.

On-chain quotes reflect the actual Curve StableSwap-NG amplification parameter and current pool state — significantly more accurate than the math estimate, especially for large trades.

Use spectra_simulate_trade to preview your full portfolio state after this trade (BEFORE / TRADE / AFTER with deltas). Use spectra_compare_yield to evaluate whether the trade makes sense relative to variable rates.

Scan all Spectra chains for the best risk-adjusted yield opportunities, sized to your capital.

Unlike spectra_get_best_fixed_yields (which ranks by raw APY), this tool computes:

• Entry price impact at YOUR capital size (a 50% APY pool with $10K liquidity is useless at $500K)

• Effective APY after amortizing entry cost over days to maturity

• Morpho looping availability and optimal leveraged net APY

• Pool capacity (max capital before price impact exceeds your threshold)

• IBT APR composition (organic base yield vs external incentive programs)

• Points program multipliers and asset tags per opportunity

• External Merkl campaign APR (incentive programs beyond native yield)

• Risk warnings (low liquidity, short maturity, high impact)

• MetaVault alternatives (curated auto-rolling LP vaults with YT compounding)

Returns opportunities ranked by effective APY (or looping net APY where available). Ranking logic: when a profitable Morpho looping market exists, ranks by looping net APY with cumulative entry cost amortized; otherwise ranks by effective APY (base APY minus annualized entry cost).

MetaVaults are shown in a separate section (not interleaved with PT rankings) because they have different risk profiles: variable APY, curator-managed, auto-rolling positions. Set include_metavaults=false to skip MetaVault scanning.

NOTE: This scans Spectra pools only. For broader coverage including Pendle markets, use mv_scan_curator_opportunities — it includes both protocols and may surface significantly more opportunities, especially at smaller capital sizes.

Effective APY is a conservative lower bound (constant-product impact model). Real Curve StableSwap-NG pools are more capital-efficient. Verify top picks with spectra_quote_trade().

Output includes conditional competing interpretations when rankings are ambiguous — e.g., thin-liquidity pools dominating the ranking, or MetaVaults with high idle ratios.

Use spectra_get_looping_strategy to drill into a specific opportunity's leverage details. Use spectra_get_pool_activity and spectra_get_portfolio to investigate trading patterns and positions. Use spectra_model_metavault to model MetaVault looping economics.

Scan all Spectra chains for YT (Yield Token) arbitrage opportunities.

Compares the IBT's actual current variable APR against the rate implied by the YT's market price. When these diverge significantly, an arbitrage opportunity may exist:

• Positive spread (IBT APR > YT implied rate): IBT earns more than the YT price implies

• Negative spread (IBT APR < YT implied rate): IBT earns less than the YT price implies

Returns opportunities sorted by absolute spread, with capital-aware entry sizing, break-even analysis, IBT APR composition (organic base yield vs external incentive programs — critical for assessing whether the spread is driven by sustainable yield), and external Merkl campaign APR when available.

Execution mechanics:

• Buying YT: The Spectra Router can flash-mint (flash-borrow IBT → mint PT+YT → sell PT on pool → user covers shortfall → user receives YT). This appears as SELL_PT in pool activity. Alternatively, minting IBT → PT+YT and selling PT separately.

• Selling YT: The Router flash-redeems (borrow IBT → buy PT from pool → burn PT+YT → repay → profit). This appears as BUY_PT in pool activity. The Curve pool does NOT trade YT directly.

• Break-even assumes the spread persists. Real variable rates fluctuate — spreads can close quickly. The break-even period is the minimum time needed, not a guarantee.

Use spectra_compare_yield for a detailed fixed-vs-variable breakdown on a specific pool. Use spectra_get_pool_activity to monitor recent trading patterns in the target pool.

Preview what a wallet's Spectra portfolio would look like after a PT trade.

Fetches the wallet's current position (if any) and the PT pool data, computes a trade quote, then shows BEFORE / TRADE / AFTER with deltas.

Works even if the wallet has no existing position (simulates a new entry). Side: "buy" = acquire PT, "sell" = dispose PT.

Note: This simulates PT trades only, not YT. YT is acquired by minting (deposit IBT to get PT+YT) and sold via the Router's flash-redeem mechanism, not through the Curve pool directly. The wallet's YT balance is shown but not modified by this simulation.

Use spectra_get_portfolio to see current full positions. Use spectra_quote_trade for a standalone price quote without portfolio context.

Simulate a large redemption on a MetaVault to assess withdrawal liquidity.

Builds a liquidity waterfall — sources of cash ordered by cost: Tier 1: Unallocated Cash (undeployed, no external — instant, no cost) Tier 1b: Avant Redemption Queue (avUSDx → avUSD burn, ~1 week cooldown per Avant docs, no price impact — emitted only when avant external positions exist; EXCLUDED from within-epoch max-safe calculation due to the delay, INCLUDED in the separate within-1-week metric) Tier 2: Naturally maturing Spectra LP positions (no cost, time-dependent) Tier 3: LP removal from Curve/Pendle pools (low-medium impact) Tier 4: PT sale on Curve pool (higher impact)

Note: "Unallocated" replaces the old "Idle" label. External positions (avant burn, pendle LP) are NOT counted in Tier 1 — they surface as Tier 1b (avant) or are excluded from all tiers (pendle external, conservative error mode).

Computes total coverage, cost to remaining depositors, and maximum safe redemption size (< 1% loss to remaining holders).

ERC-7540 constraint: once redemption is requested, the vault MUST fulfill it. There is no cancelRequest. This makes withdrawal liquidity critical.

Use spectra_get_curator_dashboard for operational overview before stress testing. Use spectra_get_pool_capacity to assess individual pool depth. Use morpho_monitor_risk for Morpho position risk.