VaultPilot MCP

READ-ONLY — current Bitcoin mainnet chain tip. Returns block height, 64-hex block hash, header timestamp (unix seconds), server-computed `ageSeconds` (now − timestamp), and — when the indexer exposes them — BIP-113 median time past + difficulty. Backed by the configured indexer (mempool.space default; `BITCOIN_INDEXER_URL` env var or `bitcoinIndexerUrl` user-config override for self-hosted Esplora). Useful for: latest-hash lookups, block-age UX context (Bitcoin block intervals are Poisson — a 40-min gap is normal but worth surfacing), indexer-freshness sanity checks before quoting balances, co…

READ-ONLY — recent Bitcoin block headers, newest-first (default 144 ≈ one day; capped at 200). Each entry: height, 64-hex hash, header timestamp, tx count, size, weight (when exposed), and — on indexers that surface it (mempool.space) — the mining pool name. Backbone for chain-health questions: 'is the chain producing blocks at the expected rate?', 'any empty blocks recently?', 'who's mining most of the recent window?'. Used internally by `get_market_incident_status({ protocol: 'bitcoin' })` to compute hash_cliff, empty_block_streak, and miner_concentration. Issue #233 v1.

READ-ONLY — bitcoind `getchaintips` output: every fork the node knows about, with `branchlen` and `status` (active / valid-fork / valid-headers / headers-only / invalid). THE primitive for fork / deep-reorg detection — Esplora indexers cannot expose this; they only know the chain they followed. Requires `BITCOIN_RPC_URL` configured (self-hosted bitcoind or a public RPC provider). Returns `available: false` with a setup hint when RPC is not configured. Issue #248 / #233 v2.

READ-ONLY — current Bitcoin fee-rate recommendations in sat/vB. Returns five labels: `fastestFee` (~next block), `halfHourFee` (~3 blocks), `hourFee` (~6 blocks), `economyFee` (~144 blocks / 1 day), and `minimumFee` (mempool floor). Sourced from mempool.space's `/v1/fees/recommended` endpoint when available; falls back to per-target estimates from the standard Esplora `/fee-estimates` for self-hosted indexers.

READ-ONLY — bitcoind `getmempoolinfo` output: tx count in mempool, total bytes, memory usage, current minimum admission feerate, total fees of mempool txs. RPC-only — Esplora's mempool view is whatever that one node sees; ours gives us the real local view + the daemon's admission policy. Used by `get_market_incident_status` to flip the `mempool_anomaly` signal from `available: false` to live computation. Requires `BITCOIN_RPC_URL` configured. Issue #248 / #236 v2.

Watch-only balance read for a registered multi-sig wallet. Walks both BIP-32 chains (chain=0 receive, chain=1 change) up to a gap-limit window (default 20, BIP-44 standard), queries each derived address via the configured Esplora indexer, returns the aggregate balance plus per-address breakdown for entries with on-chain history. No device touch — addresses are derived locally from the stored cosigner xpubs. Phase 3 supports P2WSH (`wsh`) wallets only; taproot lands in a follow-up PR.

Return the UTXO set for a registered multi-sig wallet. Same gap-limit walk as `get_btc_multisig_balance`; each UTXO carries the witnessScript + cosigner pubkeys needed to build a multi-sig PSBT input. Used internally by `prepare_btc_multisig_send` (initiator flow); also exposed directly for users who want to inspect the spendable set without preparing a tx. No device touch.

READ-ONLY — recent Bitcoin transaction history for a single address (newest-first). Each entry surfaces txid, received/sent sats from this address's perspective, the network fee, block height + time (when confirmed), and an RBF-eligible flag (sequence < 0xFFFFFFFE on at least one input). Default 25 txs, capped at 50 (one Esplora page); pagination beyond is a follow-up.

Fetch the USD price of any well-known cryptocurrency by ticker symbol or CoinGecko ID — no contract address required. Sister tool to `get_token_price`; use this for non-EVM natives (BTC, LTC, SOL, TRX, XMR, DOGE, etc.) and any asset that doesn't have an EVM ERC-20 representation. Two input modes: (a) `symbol` — case-insensitive ticker from a curated allowlist (~120 entries covering top market-cap coins, all native chain currencies VaultPilot supports, major LSTs, top stablecoins, top DeFi governance tokens, and high-question-volume memecoins). The allowlist hardcodes the canonical CoinGecko ID…

Fetch structured market info for a single Compound V3 (Comet) market — no wallet required. Returns base-token metadata, totalSupply/totalBorrow, utilization, supply+borrow APR, current pause flags, and the full collateral-asset list with each asset's symbol, decimals, priceFeed, borrow/liquidate/liquidation collateral factors, supply cap, and total amount currently supplied across all users. Use this to explain market state, answer 'what are the listed collaterals for cUSDCv3', or diagnose an incident (pause + utilization + contagion across collaterals) in one call.

Fetch Compound V3 (Comet) positions for a wallet across all known markets on the selected chains (cUSDCv3, cUSDTv3, cWETHv3, etc.). For each market the wallet touches, returns the base-token supply or borrow balance, per-asset collateral deposits, and USD valuations. Use this to answer 'my Compound positions' or before preparing a `prepare_compound_*` action so you have the right market address. Returns an empty list if the wallet has no Compound V3 exposure on the requested chains.

READ-ONLY — fetch a verified contract's ABI on any Etherscan-V2-supported EVM chain (Ethereum, Arbitrum, Polygon, Base, Optimism). Wraps the same `getsourcecode` path `prepare_custom_call` and `check_contract_security` use, so the call carries the user's `ETHERSCAN_API_KEY`, the `MAX_RESPONSE_BYTES` cap, the `sanitizeContractName` discipline, and the 24h cache. Returns `{ chain, address, isVerified, isProxy, implementation?, contractName?, compilerVersion?, abi?, abiSource }`. When the target is a proxy and `followProxy=true` (default), follows once to the implementation's ABI and reports `abi…

READ-ONLY — Curve LP positions on Ethereum stable_ng plain pools. v0.1 scope (per `claude-work/plan-curve-v1.md`): Ethereum mainnet only, stable_ng factory only, plain pools only (meta pools rejected — different ABI, separate follow-up). Returns per-pool LP token balance + gauge-staked balance + pending claimable CRV. Pools where the wallet has zero of all three are filtered out. Future PRs add: legacy pre-factory pools (3pool, fraxusdc, etc.), stable factory v1, twocrypto/crypto/tricrypto factories, Arbitrum + Polygon. The tool surface stays additive — `get_curve_positions` will keep its name…

One-paragraph 'what's going on with my portfolio right now' briefing — composed from existing tools, not new on-chain reads. Section coverage: (1) current portfolio total + window USD/% delta, (2) top 3 movers by absolute USD change across all chains, (3) Aave health-factor alerts (any HF < 1.5 surfaced with capitalized prefix and margin-to-liquidation %), (4) recent activity counts split into received / sent / swapped / supplied / borrowed / repaid / withdrew / other (action-type classification via 4byte-resolved methodName when present, directional fallback otherwise). Period: 24h (default —…

Report the active demo wallet (live mode), confirm default demo mode (no wallet set), or report why demo mode isn't active when the env var is missing or misconfigured. ALWAYS enumerates the available personas + their addresses + descriptions regardless of VAULTPILOT_DEMO state, so the agent can offer the user a choice without hardcoding the list (issue #392). RESPONSE: `{ demoActive, mode, envState: 'enabled' | 'unset' | 'invalid', personas, matrix, [active], [message] }`. When envState is 'unset' or 'invalid' the `message` field tells the user how to fix it (set `VAULTPILOT_DEMO=true` exact …

READ-ONLY — across-protocol liquidation-risk check. Fans out in parallel to Aave V3 / Compound V3 / Morpho Blue (EVM, via `wallet`) and MarginFi / Kamino (Solana, via `solanaWallet`); returns every position whose health factor is below `threshold` (default 1.5). Each row carries `protocol` (discriminator), `chain`, `market` (market addr / marketId / MarginfiAccount / obligation; null for Aave's per-chain aggregation), `healthFactor`, `collateralUsd`, `debtUsd`, and `marginToLiquidation` (% HF would need to drop to hit 1.0). At least one of `wallet` / `solanaWallet` is required. Per-protocol fa…

READ-ONLY — enumerate a Solana wallet's Kamino lending position on the main market. Returns the obligation PDA, per-reserve deposits + borrows (with USD values), totalSuppliedUsd / totalBorrowedUsd / netValueUsd, and a health factor (borrowLiquidationLimit / userTotalBorrowBorrowFactorAdjusted; >1 safe, <1 liquidatable, Infinity when no debt — same convention as Aave / MarginFi). Returns an empty list when the wallet has no Kamino userMetadata (= never used Kamino). Reserve-level pause / freeze flags surface in `warnings`.

READ-ONLY — probe the connected Ledger device over USB HID and report which app is currently open (name + version), plus an actionable hint for the agent to relay. Uses the dashboard-level GET_APP_AND_VERSION APDU so it works whether the user is on the dashboard or inside a chain app — you get 'BOLOS' / 'OS' for the dashboard and e.g. 'Solana' 1.10.2 / 'Ethereum' 1.13.0 / 'Tron' 0.2.0 / 'Bitcoin' 2.3.0 when an app is open. `deviceConnected: false` is returned cleanly (with a hint) when no Ledger is plugged in or the udev rules are missing on Linux; the tool never throws. Call this BEFORE `pair…

Report whether a WalletConnect session with Ledger Live is active (EVM chains) AND whether any TRON or Solana Ledger pairings are cached (USB HID — see `pair_ledger_tron` / `pair_ledger_solana`). Returns `accounts: 0x…[]` — the list of EVM wallet addresses the user has connected — and optionally `tron: [{ address, path, appVersion, accountIndex }, …]` and `solana: [{ address, path, appVersion, accountIndex }, …]` (one entry per paired non-EVM account, ordered by accountIndex) if the corresponding `pair_ledger_*` tool has been run at least once. Call this FIRST whenever the user refers to their…

Fetch all Aave V3 lending/borrowing positions for a wallet. Returns collateral, debt (both in USD and per-asset), health factor, LTV, and liquidation threshold across Ethereum and Arbitrum.

Fetch all Uniswap V3 liquidity-provider positions for a wallet. Returns token pair, current token amounts, fee tier, in-range status, uncollected fees (lower bound), and an approximate impermanent-loss estimate.

Return the on-chain balance for one Litecoin mainnet address via the Esplora indexer (litecoinspace.org by default; override via `LITECOIN_INDEXER_URL` env var or `userConfig.litecoinIndexerUrl`). Returns confirmed + mempool litoshis and an LTC-decimal projection. Accepts L/M/3/ltc1q/ltc1p — the read path validates format only.

READ-ONLY — litecoind `getblockstats` output. Mirror of `get_btc_block_stats` for LTC. Requires `LITECOIN_RPC_URL` configured. Issue #248 / #233 v2.

READ-ONLY — current Litecoin mainnet chain tip. Mirror of `get_btc_block_tip` for Litecoin: height, 64-hex hash, timestamp, ageSeconds, optional MTP + difficulty. Backed by the configured indexer (litecoinspace.org default; `LITECOIN_INDEXER_URL` env var or `litecoinIndexerUrl` user-config override for self-hosted Esplora). LTC blocks target 2.5 minutes — a 10-min gap is well within Poisson normal but worth surfacing. Issue #233 v1 (this tool was missing from the MCP surface despite the underlying indexer method existing in code).

READ-ONLY — recent Litecoin block headers, newest-first (default 144 ≈ 6h at 2.5-min blocks; capped at 200). Mirror of `get_btc_blocks_recent` for LTC. Used internally by `get_market_incident_status({ protocol: 'litecoin' })` to compute hash_cliff, empty_block_streak, and miner_concentration. Issue #233 v1.

READ-ONLY — litecoind `getchaintips` output. Mirror of `get_btc_chain_tips` for LTC. Requires `LITECOIN_RPC_URL` configured. Self-hosting `litecoind -prune=5000` is much cheaper than self-hosting bitcoind (~5GB on disk + ~6h IBD on a residential link), so for LTC users wanting an indexer-independent second opinion, self-hosting is the most accessible route. Issue #248 / #233 v2.

READ-ONLY — litecoind `getmempoolinfo` output. Mirror of `get_btc_mempool_summary` for LTC. Requires `LITECOIN_RPC_URL` configured. Issue #248 / #236 v2.

READ-ONLY — diagnostic surface for the hardened MarginFi client load. Returns the list of banks the bundled SDK (v6.4.1, IDL 0.1.7) had to skip while fetching the production group, with each record carrying the bank address, best-effort mint + symbol (recovered from raw bytes even when Borsh decode fails), the step where the skip happened (`decode` / `hydrate` / `tokenData` / `priceInfo`), and the raw error reason. Call this when `prepare_marginfi_*` reports that a mint you know is listed on mainnet (e.g. USDC) was missed — it will either name the bank explicitly as skipped with the root cause…

READ-ONLY — enumerate a Solana wallet's MarginFi lending positions. Probes the first 4 MarginfiAccount PDAs under the wallet (accountIndex 0..3) and returns one entry per existing account. Each entry reports the supplied and borrowed balances per bank (human amount + USD value), aggregate totals, and the health factor (assets/liabilities, >1 safe, <1 liquidatable, Infinity when no debt). Bank-level pause warnings surface in the `warnings` field. Parallel to EVM's `get_compound_positions` / `get_morpho_positions`. Returns an empty array when the wallet has no MarginfiAccount.

Return an 'is anything on fire' snapshot across every registered market for a protocol + chain. For Compound V3, returns per-market pause flags, utilization, totalSupply, totalBorrow. For Aave V3, returns per-reserve isActive/isFrozen/isPaused, utilization, totalSupplied, totalBorrowed. Each entry has a `flagged` bit: Compound flags on any pause or utilization ≥ 95% (borrowers trapped); Aave flags on paused/frozen/inactive or utilization ≥ 95%. Top-level `incident: true` if any market/reserve is flagged. Use when you suspect a governance pause, a utilization cliff, or multi-market contagion fr…

Fetch Morpho Blue positions for a wallet. If `marketIds` is omitted, the server auto-discovers the wallet's markets by scanning Morpho Blue event logs (may take several seconds on a cold call). Pass explicit `marketIds` (bytes32 each, keccak256 of MarketParams) as a fast path. Returns per-market supplied/borrowed assets and collateral.

Wallet-less NFT collection metadata: name, symbol, image, description, current floor ask + top bid (in native asset and USD), volume by 24h / 7d / 30d / all-time windows, owner count, total supply, secondary-sale royalty (basis points + recipient address). Source: Reservoir. Use this for "what's this collection's vitals?" lookups before adding it to a watchlist or evaluating exposure. EVM-only in v1 — Solana NFTs need a different API surface and are deferred. Pass the contract address on its deployed chain (defaults to ethereum). Read-only.

Recent NFT activity for a wallet across one or more supported EVM chains: mints, sales, transfers, listings (asks), bids, and cancels. Source: Reservoir's `/users/{user}/activity/v6`. Multi-chain results are merged + sorted by timestamp descending; capped at `limit` (default 25, max 100). Mirrors `get_transaction_history`'s shape but limited to NFT-relevant events — same agent ergonomics, scoped to the NFT side of the wallet. EVM-only in v1; Solana deferred. Read-only.

Issue #569. Ranked individual listings (currently active asks) for a single EVM NFT collection on a single chain, sorted floor-ascending. Distinct from `get_nft_collection`, which exposes only collection-level metadata (floor / volume / holders) and so cannot ground a 'show me the N cheapest' question. Source: Reservoir `/orders/asks/v5?status=active&sortBy=price&sortDirection=asc`. Returns rows with `tokenId`, `priceEth` / `priceUsd`, `priceCurrency`, `listingSource` (marketplace domain — opensea.io / blur.io / x2y2.io / etc.), `makerAddress` (seller), `validUntil` (expiry), and `orderKind` (…

List the NFT collections a wallet owns across EVM chains and/or Solana, with per-collection floor price (EVM only in v1) and a rolled-up total floor value. EVM source: Reservoir. Multi-chain fan-out via `Promise.allSettled` so a per-chain rate-limit or 5xx degrades to a `coverage[].errored` flag rather than aborting the whole call. Solana source (issue #433): Helius DAS `getAssetsByOwner` — pass `solanaWallet` (base58). Requires a Helius API key (free tier; configure via `set_helius_api_key` in demo mode or `vaultpilot-mcp-setup` for persistence). Returns per-collection rows without floor pric…

Wallet-level net PnL over a preset time window across EVM (Ethereum/Arbitrum/Polygon/Base/Optimism), TRON, and Solana. Returns the headline `pnlUsd` (= ending value − starting value − net user contribution), with per-chain and per-asset breakdown. Math: starting quantity per asset is reconstructed as `currentQty − netFlowQty` (clamped at zero when negative — user received the asset entirely within the window), priced at the period's start via DefiLlama historical, then `pnlUsd = walletValueChange − (inflowsUsd − outflowsUsd)`. Use this for the simple 'how much did I make?' question; pair with …

Decompose what changed in the user's portfolio over a time window — the AI version of an account statement. Returns the top-level USD change, broken down by chain and per-asset into: price moves (USD impact of price change on what was held the entire window), net deposits / withdrawals (sum of priced external transfers), and 'other' (the residual — interest accrual, swap legs, MEV, anything not cleanly attributable to price or external flow). Supports `wallet` (EVM), `tronAddress`, `solanaAddress`, `bitcoinAddress` — at least one required. Window: 24h / 7d / 30d / ytd. Returns BOTH a structure…

One-shot cross-chain portfolio aggregation for one or more wallets. Fans out across Ethereum/Arbitrum/Polygon/Base/Optimism (unless `chains` narrows it) and assembles: native ETH/MATIC balances, top ERC-20 holdings, Aave V3 and Compound V3 lending positions, Uniswap V3 LP positions, and Lido/EigenLayer staking — each valued in USD via DefiLlama. Pass `tronAddress` (base58, prefix T) alongside a single `wallet` to fold TRX + TRC-20 balances plus TRON staking into the same totals; `breakdown.tron` holds the TRON slice, `tronUsd` the subtotal, and `tronStakingUsd` the staking portion. Pass `solan…

Return a 0-100 risk score for a DeFi protocol, combining TVL size, 30-day TVL trend, contract age, audit count (DefiLlama), and Immunefi bug-bounty status. Higher = safer. The `protocol` argument is the DefiLlama slug — works for any chain DefiLlama covers, not just EVM (Solana: `marinade-finance`, `jito`, `kamino`, `marginfi`, `drift`; Tron: `justlend`, `sun-io`; EVM: `aave-v3`, `uniswap-v3`, etc.). Issue #243. SCOPE: this score measures PROTOCOL-LEVEL contract safety, governance, and audit posture (will-the-protocol-rug risk). It does NOT measure individual token upside, price direction, fut…

Fetch Safe (Gnosis Safe) multisig accounts for an EVM owner address and/or by Safe address. Returns per-Safe threshold, owners, contract version, native balance, pending and recently-executed transactions, and risk notes (single-signer threshold, all-required threshold, Safe Modules, Safe Guards). Pass `signerAddress` to discover every Safe the wallet is an owner on, OR `safeAddress` to look up one Safe directly (or both — results are unioned and deduped). `chains` defaults to `["ethereum"]`; pass an explicit array to query other supported EVM chains. Requires SAFE_API_KEY (https://developer.s…

READ-ONLY — probe which one-time setup pieces are already in place for a Solana wallet: the durable-nonce account (exists / address / current nonce value / authority) and the set of MarginfiAccount PDAs (index + address). Call this BEFORE planning a multi-step Solana flow (nonce init → MarginFi init → supply) so agents can skip redundant prepare_* calls instead of re-proposing them and letting the user correct you. Mirrors the get_ledger_status pattern of cheap chain-read setup introspection. One getAccountInfo per probed PDA; no SDK load, no oracle fetch. Returns empty arrays / exists:false w…

READ-ONLY — enumerate a Solana wallet's liquid-staking (Marinade mSOL, Jito jitoSOL) and native stake-account positions. Returns three sections: (1) Marinade — mSOL balance + SOL-equivalent via the on-chain mSolPrice field; (2) Jito — jitoSOL balance + SOL-equivalent via the stake pool's totalLamports/poolTokenSupply ratio; (3) native stakes — all SPL stake-program accounts where this wallet has withdrawer authority, each annotated with activation status (activating / active / deactivating / inactive) and validator vote account. Parallel to EVM's `get_staking_positions`. Single tool call retur…

READ-ONLY — fetch a Jupiter v6 swap quote for previewing the route, expected output, slippage, and price impact before committing to a transaction. Parallel to EVM's `get_swap_quote` (which uses LiFi). Calls the Jupiter aggregator at lite-api.jup.ag/swap/v1/quote, returns the opaque quoteResponse (which must be passed back verbatim to `prepare_solana_swap`) plus human-facing fields (symbols, amounts with decimals applied, route labels like 'Meteora DLMM' / 'Raydium CLMM', price impact %). Pass raw integer amounts in base units (e.g., '1000000' for 1 USDC). For native SOL, use the wrapped-SOL m…

Fetch Lido (stETH/wstETH) and EigenLayer staking positions for a wallet across supported chains. Returns per-protocol staked amounts, USD value, APR, and EigenLayer delegation target.

Estimate staking rewards earned over a given period (7d/30d/90d/1y) using the current APR as a proxy. This is an estimate, not an on-chain rewards query.

Get a LiFi aggregator quote for a token swap (same-chain) or bridge (cross-chain). Returns expected output, fees, execution time, and the underlying tool selected. Default is exact-in (`amount` = fromToken); set `amountSide: "to"` for exact-out quotes (`amount` = target toToken output). Source chain is always EVM. Destination can be any EVM chain, Solana, or TRON — pass `toChain: "solana"` / `toChain: "tron"` + an explicit `toAddress` (Solana base58 / TRON T-prefixed base58); the bridge protocol delivers tokens on the destination chain after the EVM source tx confirms (typically 1-15 min). Exa…

Enumerate every spender that currently holds a non-zero allowance over the wallet's balance of a specific ERC-20 token on a single EVM chain. Pulls Approval events from Etherscan's logs API filtered to the wallet as `owner`, dedups by spender (keeping the latest event per spender for provenance), then re-reads the LIVE `allowance(owner, spender)` for each via Multicall3 and drops anyone whose live value is 0 (revoked or fully consumed). Returns rows sorted by allowance descending, each carrying `spender`, optional `spenderLabel` (Aave V3 Pool / Uniswap V3 SwapRouter02 / Lido stETH / etc. resol…

Fetch a wallet's balance of any ERC-20 token or the chain's native coin. Pass `token: "native"` for ETH (or chain-native asset) or an ERC-20 contract address. Returns amount, decimals, symbol, and USD value. For TRON, pass `chain: "tron"` with a base58 wallet (prefix T) and either `token: "native"` for TRX or a base58 TRC-20 address; returns a TronBalance (same fields, base58 token id). For Solana, pass `chain: "solana"` with a base58 wallet (43-44 chars) and either `token: "native"` for SOL or an SPL mint address; returns a SolanaBalance (same fields, base58 mint).

Fetch on-chain ERC-20 metadata (symbol, name, decimals) for any token address on an EVM chain — no wallet or balance required. Also detects EIP-1967 transparent proxies and returns the current implementation address when present. Prefer this over running raw simulate_transaction calls against symbol()/name()/decimals() selectors.

Fetch the USD price of a token via DefiLlama. Pass `token: "native"` for the chain's native asset (ETH on ethereum/arbitrum, MATIC on polygon) or an ERC-20 contract address. Prefer this over get_swap_quote for pure price lookups — no wallet or liquidity simulation needed. EVM-only — for non-EVM natives (BTC, LTC, SOL, XMR, etc.) or any well-known coin without an EVM contract address, use `get_coin_price` instead. SCOPE: returns the current spot USD price — a snapshot, not a forecast. It is NOT a buy/sell signal, price prediction, target, or token-pick endorsement. AGENT BEHAVIOR: this tool sur…

Fetch a wallet's recent on-chain transaction history on a single chain, merged across external (user-initiated) txs, ERC-20/TRC-20 token transfers, and internal (contract-initiated) txs. Results are sorted newest-first, capped at `limit` (default 25, max 50), and annotated with decoded method names (via 4byte.directory) and historical USD values at the time of each tx (via DefiLlama). Supports Ethereum/Arbitrum/Polygon/Base/Optimism via Etherscan, TRON via TronGrid, and Solana via the configured Solana RPC. On Solana, results include a fourth item type `program_interaction` for DeFi calls (Jup…

Poll a transaction's status via the chain's RPC (EVM / Solana) or TronGrid (TRON). Returns pending / success / failed, plus 'dropped' on Solana when the tx is mathematically unable to land. Pass chain='tron' with the bare hex txID for TRON; chain='solana' with the base58 signature for Solana. For Solana, ALSO pass whichever drop-detection field send_transaction returned: (a) `durableNonce` for nearly every send (native/SPL sends, nonce_close, jupiter_swap, all marginfi_* actions) — the tool reads the on-chain nonce account and reports 'dropped' if it rotated past the baked value; or (b) `lastV…

Read TRON staking state for a base58 address: claimable voting rewards (WithdrawBalance-ready), frozen TRX under Stake 2.0 (bandwidth + energy), pending unfreezes with unlock timestamps, the live account-resource meter (`resources`) showing immediately-consumable bandwidth units (free + staked pools), energy units, and voting-power units, AND the per-SR vote allocation (`votes[]` — same shape as `list_tron_witnesses(addr).userVotes`, issue #271). The resource meter is what tx execution actually charges against — frozen TRX only determines the daily limit. The `votes[]` baseline is what callers…

Re-emit the prepared-tx JSON and VERIFY-BEFORE-SIGNING block for a known handle. Use this when the original prepare_* tool output has dropped out of your context (compaction, long sessions). The response shape and verification block match the original prepare_* call exactly. NEVER recover a verification block by reading tool-result files from disk — call this tool instead. Handles live in-memory for 15 minutes after issue.

READ-ONLY — return the recommended upgrade flow for the running install path. Combines (1) `process.argv`/`process.execPath` heuristics that classify the install as one of `npm-global` / `npx` / `bundled-binary` / `from-source` / `unknown` with (2) cached state from the once-per-session npm-registry version check the server already runs lazily on first tool call. Returns: `current` (server version), `latest` (most recent npm registry response, or `null` if the lazy check hasn't resolved yet), `updateAvailable` (strict-newer comparator), `installPath` (detected kind), `command` (the one-liner t…

READ-ONLY — report what the server knows about its local config without revealing any secret values. Returns the config-file path + existence, server version, per-chain RPC URL source classification (env-var / provider-key / custom-url / public-fallback), API-key presence + source per service (Etherscan, 1inch, Safe, TronGrid, WalletConnect — boolean + source enum, never values), counts of paired Ledger accounts (Solana / TRON), the WC session-topic SUFFIX (last 8 chars only — same convention as get_ledger_status), the agent-side preflight-skill install state, a `setupHints` array (each entry …

Return a sparse verification artifact for a prepared tx — raw calldata (or TRON rawDataHex), chain, to/value, payloadHash, preSignHash if preview_send has pinned gas, plus a static prompt instructing a second LLM on how to decode the bytes from scratch. Intended for adversarial independent verification: the user copies this artifact into a second LLM session (different provider recommended) so the second agent produces an independent decode with no shared context from the current conversation. If the two decodes disagree — or if the preSignHash doesn't match what Ledger displays at sign time —…

Decode a `vp1.…` read-only share token (generated by someone else's `generate_readonly_link`) into the embedded wallet bundle. Accepts either the raw token or an http(s) URL containing a `?t=vp1.…` / `#t=vp1.…` parameter. Returns `{ wallets, scope, name, issuedAt, expiresAt, id }` — the recipient agent then passes those wallet addresses to standard portfolio reads (`get_portfolio_summary`, `get_lending_positions`, `get_token_allowances`, `get_transaction_history`, etc.) using the recipient's own configured RPCs. Refuses expired tokens with a clear error pointing the user back at the issuer. v1…

Parse and validate a shared-strategy JSON produced by `share_strategy` (someone else's, or one the user generated earlier). Pass either the stringified form or the parsed object via `json`. Returns the validated `SharedStrategy` for read-only inspection — protocol allocations, per-position percentages, optional health-factor / fee-tier / APR metadata. The same redaction scan that runs on emit also runs on import — addresses or tx hashes anywhere in the imported JSON cause a RedactionError, so a malicious sender cannot smuggle a wallet identifier through fields the recipient might not eyeball. …

Return the joined per-label view across chains. Each row contains the label, addresses keyed by chain, optional notes / tags, the earliest `addedAt` across the joined entries, and an optional `unsigned: true` flag (issue #428) when at least one chain entry is unsigned (in-memory only). Strict-fail on tamper (signed disk blobs): any signature failure / anchor mismatch / version rollback throws immediately (CONTACTS_TAMPERED / CONTACTS_ANCHOR_MISMATCH / CONTACTS_VERSION_ROLLBACK) rather than silently dropping rows — agents must surface the failure to the user. Unsigned in-memory entries are merg…

List the read-only share tokens the user has generated. By default returns only ACTIVE invites (not revoked, not expired); pass `includeInactive: true` to see history. Each entry returns `{ id, name, scope, issuedAt, expiresAt, revokedAt, expired, active, walletCounts, totalAddresses }` — note the addresses themselves are NOT re-surfaced here, only counts per chain (the raw token isn't stored either, only its sha256 hash). Pair with `revoke_readonly_invite({ name })` to invalidate an invite. Read-only.

Read-only validator-ranking helper for `prepare_native_stake_delegate`. Pulls the stakewiz.com public feed (no API key required) and returns a filtered + sorted list of Solana validators with the columns most relevant to delegation: composite quality score (`wizScore`), commission, MEV (Jito) status + commission, total APY estimate (inflation + MEV), activated stake, delinquent flag, superminority penalty flag, skip rate, uptime, version, country, and a per-validator stakewiz.com profile URL the user can open in a browser to verify independently. Default filters: excludeDelinquent=true. Defaul…

List TRON Super Representatives (SRs) + SR candidates, ranked by total vote count. Active SRs (rank ≤ 27, `isActive: true`) produce blocks and distribute the 160 TRX/block voter-reward pool pro-rata to their voters; every witness in the top 127 shares the same APR estimate (pro-rata split of the pool); witnesses ranked > 127 get `estVoterApr: 0`. APR estimates assume current mainnet constants (3-second blocks, 27 active SRs, 365 days/year) and are best-effort — actual rewards depend on missed blocks and competing voters shifting between your vote tx and reward claim. When `address` is passed, …

Pair the host's directly-connected Ledger device for Bitcoin signing. REQUIREMENTS: Ledger plugged in over USB, device unlocked, the 'Bitcoin' app open on-screen. Ledger Live's WalletConnect relay does NOT expose `bip122` accounts to dApps, so Bitcoin signing goes over USB HID via `@ledgerhq/hw-app-btc` (same USB path as Solana / TRON). ONE CALL ENUMERATES ALL FOUR ADDRESS TYPES for the requested `accountIndex` (default 0): legacy P2PKH (`44'/0'/<n>'/0/0` → `1...`), P2SH-wrapped segwit (`49'/0'/<n>'/0/0` → `3...`), native segwit P2WPKH (`84'/0'/<n>'/0/0` → `bc1q...`), and taproot P2TR (`86'/0'…

Initiate a WalletConnect v2 pairing session with Ledger Live. Returns a URI and ASCII QR code — paste into Ledger Live's WalletConnect screen to complete pairing. The session persists for future transactions. EVM chains only; for TRON use `pair_ledger_tron` instead.

Pair the host's directly-connected Ledger device for Litecoin signing. REQUIREMENTS: Ledger plugged in over USB, device unlocked, the 'Litecoin' app open on-screen. Ledger Live's WalletConnect relay does not expose Litecoin accounts to dApps, so signing goes over USB HID via `@ledgerhq/hw-app-btc` (the same SDK as Bitcoin, with `currency:'litecoin'` selecting Litecoin-specific encoding). One call enumerates the four BIP-44 address types (legacy `L…`, p2sh-segwit `M…`, native segwit `ltc1q…`, taproot `ltc1p…`) for the given account index. BIP-44 coin_type 2. Per-type fault-tolerant: each addres…

Pair the host's directly-connected Ledger device for Solana signing. REQUIREMENTS: Ledger plugged into the machine running this MCP (USB, not WalletConnect), device unlocked, and the 'Solana' app open on-screen. Ledger Live's WalletConnect integration does NOT expose Solana accounts, so Solana signing goes over USB HID via @ledgerhq/hw-app-solana (same USB path as TRON). Reads the device address at `m/44'/501'/<accountIndex>'` (default accountIndex=0 — the first Solana account in Ledger Live) and caches it so `get_ledger_status` can report it under the `solana: [...]` section. Call multiple ti…

Pair the host's directly-connected Ledger device for TRON signing. REQUIREMENTS: Ledger plugged into the machine running this MCP (USB, not WalletConnect), device unlocked, and the 'Tron' app open on-screen. Ledger Live's WalletConnect relay does not currently honor the `tron:` CAIP namespace, so TRON signing goes over USB HID via @ledgerhq/hw-app-trx. Reads the device address at m/44'/195'/<accountIndex>'/0/0 (default accountIndex=0) and caches it so `get_ledger_status` can report it. Call multiple times with different `accountIndex` values (0, 1, 2, …) to pair additional TRON accounts — each…

Build an unsigned Aave V3 borrow transaction (variable rate — stable rate is deprecated and reverts on production markets). The borrower must already have sufficient collateral supplied.

Build an unsigned Aave V3 repay transaction. If an ERC-20 approve() is required first, it is returned as the outer tx and repay is in `.next`. Pass `amount: "max"` to repay the full debt.

Build an unsigned Aave V3 supply transaction. If an ERC-20 approve() is required first, it is returned as the outer tx and the supply tx is embedded in `.next`. Both must be signed for the supply to succeed.

Build an unsigned Aave V3 withdraw transaction. Pass `amount: "max"` to withdraw the entire aToken balance.

Build an unsigned Bitcoin PSBT-v0 that bridges native BTC to a token on another chain via LiFi's aggregator. LiFi auctions the route across intent solvers (NEAR Intents, Garden, Thorswap, Chainflip, Symbiosis, …) and returns a PSBT depositing to the chosen solver's vault address with an OP_RETURN memo committing to the cross-chain destination. Destinations: every EVM chain (`ethereum`/`arbitrum`/`polygon`/`base`/`optimism`) and Solana — TRON has no LiFi route from BTC and is rejected. Source-side scope (Phase 1, mirrors prepare_btc_send): native segwit and taproot only. Returns a 15-min handle…

Initiator flow — build a tx FROM a registered multi-sig wallet, sign it with our Ledger key in the same call, return the partial PSBT for cosigners to sign. Pipeline: (1) fetch UTXOs across the wallet's gap-limit window, (2) coin-select with a multi-sig-aware vbyte estimator (P2WSH `sortedmulti(M,...,N)` inputs are ~2-4× P2WPKH), (3) resolve a fresh chain=1 change address (lowest unused index), (4) build PSBT v0 with witnessUtxo + nonWitnessUtxo (Ledger app 2.x requirement) + witnessScript + bip32_derivation for ALL cosigners, (5) sign with our Ledger via the existing co-signer flow (the devic…

Build a BIP-125 Replace-By-Fee replacement for a stuck mempool BTC tx. Reuses the original tx's exact input set, preserves every recipient verbatim, and shrinks the change output to absorb the fee bump. Sequence stays at 0xFFFFFFFD so the replacement is itself RBF-eligible (the user can bump again if the new rate is still too low). Returns a 15-min handle the agent forwards to send_transaction; the Ledger BTC app clear-signs every output + new fee on-screen, so there is NO blind-sign hash to pre-match in chat. Refusal cases: original tx already confirmed; no input is BIP-125-eligible; any inpu…

Build an unsigned Bitcoin native-send PSBT (segwit/taproot only in Phase 1). Returns a 15-min handle the agent forwards to send_transaction; the Ledger BTC app clear-signs every output (address + amount) + fee on-screen, so there is NO blind-sign hash to pre-match in chat. The verification block surfaces every output's address, amount in BTC, isChange flag, fee (BTC + sat/vB), and RBF flag. Fee selection: pass `feeRateSatPerVb` for an explicit sat/vB number, OR `feePriority` for a fuzzy preset (`fastestFee` / `halfHourFee` / `hourFee` / `economyFee` / `minimumFee` — issue #435) that resolves t…

Build an unsigned Compound V3 borrow transaction. Compound V3 encodes a borrow as `withdraw(baseToken)` drawn beyond the wallet's supplied balance — the base token is resolved on-chain from the Comet market so you only pass the market address and amount. Requires the wallet to have already supplied enough collateral in that market; `get_compound_positions` shows the current collateral mix. Returns a handle + human-readable preview for the user to sign on Ledger; no approval step is needed (borrowing doesn't pull tokens from the wallet).

Build an unsigned Compound V3 repay transaction — encoded as supply(baseToken) against an outstanding borrow. Includes an approve step if needed. Pass `amount: "max"` for a full repay.

Build an unsigned Compound V3 supply transaction (base token or collateral). If an ERC-20 approve() is required first, it is returned as the outer tx with supply in `.next`.

Build an unsigned Compound V3 withdraw transaction. Pass `amount: "max"` to withdraw the full supplied balance.

Build an unsigned Curve `add_liquidity` transaction for a stable_ng plain pool on Ethereum. Bundles ERC-20 approvals (one per non-zero deposit slot) before the action call via `chainApproval`. Pass `amounts` as a decimal-string array matching the pool's `N_COINS` (use '0' for slots you're not depositing into — single-coin deposit). Slippage gate is REQUIRED: pass either `minLpOut` (explicit decimal-string uint256) OR `slippageBps` (server computes via `calc_token_amount * (1 - bps/10000)`). v0.1 scope: stable_ng plain pools only — meta pools rejected. Use `get_curve_positions` to discover vali…

Build an unsigned Curve swap on Ethereum. Issue #615. Supports the canonical legacy stETH/ETH pool (0xDC24316b9AE028F1497c275EB9192a3Ea0f67022 — historically the tightest-spread venue for stETH↔ETH) and any plain pool registered with the stable_ng factory (covers crvUSD/USDC, USDe/USDC, etc.). Pass `pool` + `fromToken` + `toToken`; the tool resolves coin indices from the pool's `coins` array. Use `fromToken: "native"` for the ETH leg of the stETH/ETH pool (the only currently-supported pool whose `coins(i)` returns the ETH sentinel). Slippage gate REQUIRED: `slippageBps` (server reads `get_dy` …

ESCAPE HATCH for arbitrary EVM contract calls — Timelock proposals, governance hooks, DAO ops, anything not covered by a protocol-specific `prepare_*`. BYPASSES the canonical-dispatch allowlist by design; the schema's `acknowledgeNonProtocolTarget: true` literal is the user's affirmative gate. ABI source: pass `abi: [...]` inline (preferred when you have the project's published artifact), OR omit it and the tool fetches via Etherscan V2 — refuses on unverified contracts with NO raw-bytecode fallback. Proxies are followed once to the implementation when Etherscan exposes the link; deeper proxy …

Build an unsigned EigenLayer StrategyManager.depositIntoStrategy transaction. Includes an ERC-20 approve step if needed.

Build an unsigned Jito stake-pool deposit tx: deposit `amountSol` SOL into Jito's stake pool and receive jitoSOL (Jito's liquid-staking token). Uses the SPL stake-pool program's raw `DepositSol` instruction with the user's wallet as the on-chain `fundingAccount` — no ephemeral keypair, Ledger-compatible. The high-level @solana/spl-stake-pool helper would generate an ephemeral SOL-transfer keypair (incompatible with Ledger-only signing); we hand-build the ix to avoid that. The jitoSOL ATA is created automatically on first stake (~0.002 SOL ATA rent, reclaimable). DURABLE NONCE REQUIRED — wallet…

Build a Kamino borrow tx — pulls liquidity from a reserve as debt against the obligation's existing collateral. Refuses if the wallet hasn't run prepare_kamino_init_user; refuses if the mint isn't listed on Kamino's main market. On-chain LTV gate: borrow reverts if it would push the obligation over the reserve's `borrowLimit` (the simulation gate catches this before signing). DURABLE NONCE REQUIRED + same blind-sign treatment as prepare_kamino_supply.

First-time Kamino setup. Creates the user lookup table + userMetadata PDA + obligation PDA (VanillaObligation, tag 0) on Kamino's main market in a single tx. ONE-TIME — required prerequisite before prepare_kamino_supply / borrow / withdraw / repay. Refuses if userMetadata already exists (use the supply tool directly). Costs ~0.028 SOL total in rent for the three accounts (recoverable via Kamino's account-close flow when fully exiting). DURABLE NONCE REQUIRED. BLIND-SIGN on Ledger — Kamino's program isn't in the Solana app's clear-sign allowlist; match the Message Hash on-device after `preview_…

Build a Kamino repay tx — pays down outstanding debt in the named reserve. Refuses with a clear error if the wallet has no debt in the reserve. The on-chain program clamps repayment at outstanding debt, so over-repaying just doesn't burn the excess (no funds lost). DURABLE NONCE REQUIRED + same blind-sign treatment as prepare_kamino_supply.

Build a Kamino deposit (supply) tx. Refuses if the wallet doesn't have Kamino userMetadata + obligation already initialized — run prepare_kamino_init_user first. Validates that the mint is listed on Kamino's main market; resolves decimals from the reserve's mint metadata so callers pass human amounts ("100" = 100 USDC, "0.5" = 0.5 SOL). DURABLE NONCE REQUIRED + same Ledger blind-sign treatment as prepare_kamino_init_user. The returned tx packs [computeBudget, ATA setup if needed, reserve refresh, obligation refresh, deposit, cleanup] under v0 + Kamino's market ALTs.

Build a Kamino withdraw tx — pulls liquidity out of a previously-supplied reserve. Refuses with a clear error if the wallet has no deposit in the named reserve. Health-factor gated on-chain: withdraws that would leave the obligation under-collateralized for outstanding debt revert (caught by the simulation gate). DURABLE NONCE REQUIRED + same blind-sign treatment as prepare_kamino_supply.

Build an unsigned Lido stake transaction (wraps ETH into stETH via stETH.submit). The tx's value field is the ETH amount to stake.

Build an unsigned Lido withdrawal request transaction. Wraps `requestWithdrawals` on the Lido Withdrawal Queue and includes an approve step if needed.

Build an unsigned wstETH.unwrap transaction that converts wstETH (non-rebasing) back into stETH (rebasing). No approval needed — burns wstETH from the caller's balance.

Build an unsigned wstETH.wrap transaction that converts stETH (rebasing) into wstETH (non-rebasing). 1:1 by share count, no DEX fee. Includes an stETH approve step to the wstETH contract if needed.

Build an unsigned Litecoin native-send PSBT. Same pipeline as `prepare_btc_send`: fetch UTXOs + fee rate, run coin-selection, build a PSBT v0 with `nonWitnessUtxo` populated on every input (Ledger app 2.x requirement). Initial release: source addresses must be native segwit (`ltc1q…`) or taproot (`ltc1p…`); recipients can be L/M/ltc1q/ltc1p (legacy 3-prefix P2SH refused on send because bitcoinjs-lib ties the `scriptHash` byte to a single network object). Returns a handle consumed by `send_transaction`, which signs over USB HID with the Litecoin app and broadcasts via the indexer.

Build an unsigned MarginFi BORROW tx against the user's supplied collateral. Pre-flight refuses if the account has zero free collateral. The SDK computes the required oracle-refresh instructions and the health-factor gate is enforced on-chain — but this tool is the right place to surface a clear error rather than burning SOL on a reverting tx. DURABLE NONCE + prepare_marginfi_init prerequisites identical to prepare_marginfi_supply. BLIND-SIGN on Ledger.

One-time setup: build a tx that creates a deterministic MarginfiAccount PDA under the user's wallet on MarginFi mainnet. Uses `marginfi_account_initialize_pda` so only the wallet (authority + fee_payer) signs — no ephemeral keypair required, Ledger-compatible. PDA seeds are ["marginfi_account", group, wallet, accountIndex, 0], with `accountIndex` defaulting to 0. After broadcast, `prepare_marginfi_supply / withdraw / borrow / repay` for this wallet will use this MarginfiAccount automatically. COST: ~0.01698 SOL rent-exempt minimum (for the 2312-byte PDA) + ~0.000005 SOL tx fee. The rent is PAI…

Build an unsigned MarginFi REPAY tx against outstanding debt in the named bank. Pass `repayAll: true` to repay the full outstanding debt (also clears the balance slot). DURABLE NONCE + prepare_marginfi_init prerequisites identical to prepare_marginfi_supply. BLIND-SIGN on Ledger.

Build an unsigned MarginFi SUPPLY tx for a given bank (by symbol or mint). Supplies the specified amount of the underlying token into the user's MarginfiAccount position in that bank, earning the bank's supply APY. DURABLE NONCE REQUIRED + prepare_marginfi_init must have run first; otherwise this tool errors. Pre-flight: bank-pause check; invalid-mint check (MarginFi only lists a subset of SPL tokens). Uses v0 VersionedTransaction + MarginFi group ALTs for compact wire size. BLIND-SIGN on Ledger — match the Message Hash on-device after `preview_solana_send`.

Build an unsigned MarginFi WITHDRAW tx. Withdraws the specified amount (or ALL, via `withdrawAll: true`) from the user's supplied position in the named bank. Pre-flight refuses if the account has zero free collateral (the withdraw would push the health factor below the maintenance threshold — the on-chain tx would revert). DURABLE NONCE + prepare_marginfi_init prerequisites identical to prepare_marginfi_supply. BLIND-SIGN on Ledger.

Build an unsigned Marinade stake tx: deposit `amountSol` SOL into Marinade and receive mSOL (Marinade's liquid-staking token). Uses the Marinade SDK's `marinade.deposit` so the on-chain Authorized signer is the user's wallet — no ephemeral keypair, Ledger-compatible. The mSOL ATA is created automatically on first stake (~0.002 SOL ATA rent, reclaimable). DURABLE NONCE REQUIRED — the wallet must have run `prepare_solana_nonce_init` first; otherwise this tool errors. BLIND-SIGN on Ledger (Marinade's program is not in the Solana app's clear-sign registry) — match the Message Hash on-device after …

Build an unsigned Marinade IMMEDIATE liquid-unstake tx: burn `amountMSol` mSOL and receive SOL in the same tx via Marinade's liquidity pool (NOT delayed-unstake / OrderUnstake — that flow returns full SOL after one epoch but requires an ephemeral ticket-account signer the Ledger-only signing model can't provide; tracked as a follow-up). The pool charges a small fee (typically 0.3% — varies with pool depth) in exchange for instant liquidity. DURABLE NONCE REQUIRED + same Ledger signing constraints as `prepare_marinade_stake`. BLIND-SIGN on Ledger.

Build an unsigned Morpho Blue borrow transaction. Requires pre-existing collateral in the market.

Build an unsigned Morpho Blue repay transaction. Includes an approve step if needed. Explicit amount only — "max" is not supported.

Build an unsigned Morpho Blue supply transaction — deposits the market's loan token to earn lending yield. Market params (loan/collateral tokens, oracle, IRM, LLTV) are resolved on-chain from the market id, so only wallet/marketId/amount are required. If the wallet's current allowance is insufficient, an ERC-20 approve tx is emitted first (chainable via `.next`); control the cap with `approvalCap` (defaults to unlimited for UX, pass 'exact' or a decimal ceiling to scope it). Returns a handle + preview for Ledger signing.

Build an unsigned Morpho Blue supplyCollateral transaction — adds collateral to a market. Includes an approve step if needed.

Build an unsigned Morpho Blue withdraw transaction (withdraws supplied loan token). Explicit amount only — "max" is not supported; query your position first.

Build an unsigned Morpho Blue withdrawCollateral transaction — removes collateral from a market to send back to the wallet. Only withdraws the exact amount specified; `"max"` is NOT supported because Morpho's isolated-market accounting doesn't expose a clean max-safe value without simulating against the market's oracle/LLTV (query `get_morpho_positions` first to know your deposited collateral). Will revert on-chain if the withdrawal would push the position below the liquidation threshold. No approval step needed. Returns a handle + preview for Ledger signing.

Build an unsigned native-coin send transaction (ETH on Ethereum/Arbitrum). Pass a human-readable amount like "0.5".

Build an unsigned native-stake deactivate tx. Initiates the one-epoch (~2-3 days) cooldown after which the stake becomes withdrawable; the stake earns no rewards during deactivation. Wallet must be the stake account's staker authority. After the cooldown lapses, run prepare_native_stake_withdraw to drain the account (or partial-withdraw to leave it open). DURABLE NONCE REQUIRED + same Ledger blind-sign treatment as prepare_native_stake_delegate. The on-chain stake program reverts if the stake is already deactivating/inactive — the simulation gate catches it.

Build an unsigned native-stake-program tx that creates a fresh stake account at a deterministic address (derived per (wallet, validator) via createAccountWithSeed) and delegates it to the given validator vote account. Funds the stake account with `amountSol` SOL of active principal PLUS a ~0.00228 SOL rent-exempt seed (reclaimable on full withdraw). Authority is the user's wallet for both staker + withdrawer roles — no separate authority handoff is supported in this server. DURABLE NONCE REQUIRED. Refuses if a stake account already exists at the deterministic address (the user almost certainly…

Build an unsigned native-stake withdraw tx. Pulls `amountSol` SOL (or 'max' for the full lamport balance) from an inactive stake account back into the wallet. 'max' closes the account and reclaims the rent-exempt seed; partial-withdraw leaves the account open. Stake MUST be inactive (one full epoch after deactivate) — on-chain reverts otherwise; the simulation gate catches it. DURABLE NONCE REQUIRED + same Ledger blind-sign treatment as prepare_native_stake_delegate.

Build an unsigned `approve(spender, 0)` transaction that revokes the allowance the wallet previously granted to `spender` on `token`. Pre-flight check refuses when the live allowance is already 0 — that call would burn gas for nothing, and almost certainly means the user named the wrong (token, spender) pair. Resolves a friendly spender label from the canonical CONTRACTS table when one matches (Aave V3 Pool, Uniswap V3 SwapRouter02, Lido stETH, Compound V3 cUSDCv3, Morpho Blue, etc.) so the description + Ledger preview reads as "Revoke USDC allowance for Aave V3 Pool (0x...)" instead of a raw …

Build an unsigned Rocket Pool stake transaction (RocketDepositPool.deposit() payable, mints rETH at the current exchange rate). Ethereum mainnet only — rETH on L2s is bridged and cannot be deposit-and-mint. Preflights `getMaximumDepositAmount()` to refuse if the deposit pool is paused or at capacity.

Build an unsigned Rocket Pool unstake transaction (rETH.burn(uint256), redeems rETH for ETH from on-protocol collateral). No approval needed — burn operates on caller's balance. Preflights wallet rETH balance and rETH contract collateral; if collateral is insufficient, refuses with a hint to unwind via the rETH/ETH Uniswap V3 pool instead.

Add an additional approveHash signature to a Safe (Gnosis Safe) transaction that's ALREADY in the queue (proposed elsewhere — Safe Web UI, another VaultPilot install, or a co-signer). Returns an UnsignedTx that calls `Safe.approveHash(safeTxHash)` for the given signer; broadcast via `send_transaction`, then call `submit_safe_tx_signature` to push the new signature to Safe Transaction Service. Use `prepare_safe_tx_propose` instead when you're proposing a NEW Safe tx.

Build the final on-chain `execTransaction` UnsignedTx that lands a Safe (Gnosis Safe) multisig payload. The executor doesn't need to have pre-approved on-chain — when `msg.sender` is an owner, the Safe contract treats their inline `(r=msg.sender, s=0, v=1)` signature as implicit consent. So one of the threshold "signatures" can be the executor themselves; the rest come from the on-chain `approvedHashes` registry filled by previous `prepare_safe_tx_propose` / `prepare_safe_tx_approve` calls. Refuses to build the tx when the threshold isn't met (which would just revert at execute time). Resolves…

Propose a new Safe (Gnosis Safe) multisig transaction. Wraps an inner action — either a previous prepare_*'s `handle` (recommended; pulls to/value/data from server-side state) OR raw `to / value / data` — into a SafeTx, computes its EIP-712 hash, and returns an UnsignedTx that calls `Safe.approveHash(safeTxHash)`. The proposer broadcasts that approveHash via `send_transaction`; once mined, call `submit_safe_tx_signature` to post the proposal to Safe Transaction Service. Uses the on-chain approveHash flow (NOT off-chain `eth_signTypedData_v4`) — preserves the WalletConnect anti-Permit2-phishing…

Build an unsigned LiFi-routed swap or bridge with Solana as the source chain. Returns a Solana v0 tx the user signs on Ledger. Two flows share this surface: (1) IN-CHAIN swap when toChain="solana" — LiFi internally routes through Jupiter / Orca / similar; consider `prepare_solana_swap` (Jupiter direct) as the more direct path for in-chain only. (2) CROSS-CHAIN bridge when toChain is an EVM chain — LiFi aggregates Wormhole, deBridge, Mayan, Allbridge. The Solana source tx confirms first; destination delivery happens after via the bridge protocol (typically 1-15 min). DURABLE NONCE REQUIRED. The…

Build an unsigned SOL native-transfer DRAFT via SystemProgram.transfer. Returns a compact preview + opaque handle — but does NOT yet serialize the message or fetch a blockhash (those happen in `preview_solana_send`, called right before `send_transaction`, to keep the ~60s blockhash validity window from being burned during user review). Run `pair_ledger_solana` once per session first so the Solana app is open and the device address is verified. Amount is in SOL (e.g. "0.5") or "max" for full balance minus fee + safety buffer. Priority fee is added dynamically only when `getRecentPrioritizationF…

Tear down a previously-initialized durable-nonce account and return its full balance (~0.00144 SOL) to the main wallet. ix[0] = SystemProgram.nonceAdvance (self-protecting, same pattern as any durable-nonce-protected send — so this close tx itself won't expire during Ledger review), ix[1] = SystemProgram.nonceWithdraw (drains the balance). After broadcast, subsequent sends from this wallet will refuse until `prepare_solana_nonce_init` is run again. Refuses if no nonce account exists for the wallet.

Explicit one-time setup of a per-wallet durable-nonce account at the deterministic PDA `PublicKey.createWithSeed(wallet, 'vaultpilot-nonce-v1', SystemProgram.programId)`. MOST USERS DO NOT NEED TO CALL THIS DIRECTLY — `prepare_solana_native_send` / `prepare_solana_spl_send` auto-bundle the same setup into the user's first send. Use this tool when the user wants the setup standalone (e.g. before a Jupiter swap or MarginFi action, which can't safely auto-bundle due to size + ALT constraints), or to re-init after a `prepare_solana_nonce_close`. Costs ~0.00144 SOL rent-exempt seed + ~0.000005 SOL …

Build an unsigned SPL token transfer DRAFT via Token.TransferChecked. Returns a compact preview + opaque handle — but does NOT yet serialize the message or fetch a blockhash. When the user says 'send', call `preview_solana_send(handle)` to pin a fresh blockhash, compute the Message Hash, and emit the CHECKS agent-task block, then call `send_transaction`. Run `pair_ledger_solana` first. Pass the base58 SPL mint address (canonical decimals resolved for USDC, USDT, JUP, BONK, JTO, mSOL, jitoSOL; otherwise read from chain). If the recipient does NOT yet have an Associated Token Account for this mi…

Build an unsigned Jupiter-routed swap DRAFT. Takes the `quote` object returned by `get_solana_swap_quote` and calls Jupiter's /swap-instructions endpoint to get the deconstructed instruction list, then composes the final v0 tx: [nonceAdvance, ...computeBudget, ...setup, swap, cleanup?, ...other]. DURABLE NONCE REQUIRED — if the wallet hasn't run `prepare_solana_nonce_init`, this errors pointing to it. Uses v0 VersionedTransaction with Address Lookup Tables (Jupiter routes commonly exceed legacy-tx account limits). Returns a compact preview + opaque handle; NOT yet signable — when the user says…

Build an unsigned SunSwap V2 same-chain swap on TRON. SunSwap V2 is a Uniswap-V2 fork; this tool routes through the V2 router (TNJVzGqKBWkJxJB5XYSqGAwUTV15U24pPq) using the standard `swapExactETHForTokens` / `swapExactTokensForETH` / `swapExactTokensForTokens` selectors based on which side is native TRX. Path encoding: TRX→TRC20 = [WTRX, toToken]; TRC20→TRX = [fromToken, WTRX]; TRC20→TRC20 = [fromToken, WTRX, toToken]. The builder (1) calls getAmountsOut on the router via /triggerconstantcontract to compute the expected output, (2) derives minOut as quotedOut * (10000 - slippageBps) / 10000, (…

Prepare an unsigned swap or bridge transaction via LiFi aggregator. Same-chain swaps use the best DEX route; cross-chain swaps use a bridge + DEX combo. Default is exact-in (`amount` = fromToken); set `amountSide: "to"` for exact-out (`amount` = target toToken output, e.g. "I want 100 USDC out"). Source chain is always EVM. Destination can be any EVM chain, Solana, or TRON. For non-EVM destinations pass `toChain: "solana"` / `"tron"` + an explicit `toAddress` in the destination chain's format; the user signs an EVM tx and the bridge protocol delivers tokens to the destination after confirmatio…

Build an unsigned `approve(spender, amount)` transaction that raises (or sets) an ERC-20 allowance — the structured inverse of `prepare_revoke_approval`. `amount` is a decimal in token units (e.g. "10" for 10 USDC) or the literal "max" for unlimited. Refuses unlimited approvals to canonical no-key addresses (`0x0…0`, `0x0…dEaD`, `0xdEaD…0`, `0xff…ff`) with `BURN_ADDRESS_UNLIMITED_APPROVAL`; override via `acknowledgeBurnApproval: true` only when the user explicitly asked for that exact spender + unlimited amount. Resolves a friendly spender label from the canonical CONTRACTS table so the descri…

Build an unsigned ERC-20 transfer transaction. Pass `amount: "max"` to send the full balance (resolved at build time). If the user named the token by symbol, call `resolve_token` first to disambiguate native-vs-bridged variants (USDC vs USDC.e on Arbitrum/Polygon/Optimism, USDC vs USDbC on Base) and surface the warning to the user before committing to a contract.

Build an unsigned TRON WithdrawBalance transaction that claims accumulated voting rewards to the owner's balance. TRON enforces a 24-hour cooldown between claims — TronGrid will reject (surfaced as an error) if the previous claim was inside the window. Pair with `get_tron_staking` first to read `claimableRewards` and avoid empty-claim tx builds. Returns a preview + opaque handle; forward via `send_transaction` for USB-HID signing on the paired Ledger.

Build an unsigned TRON Stake 2.0 FreezeBalanceV2 transaction. Locks TRX to earn `bandwidth` (fuels plain transfers) or `energy` (fuels smart-contract calls) and gains proportional voting power. IMPORTANT: freezing alone does NOT accrue TRX rewards — `claimableRewards` (see `get_tron_staking`) only grows after the user also votes for a Super Representative. Pair this tool with `list_tron_witnesses` + `prepare_tron_vote` for the full reward-earning flow. Unlocking requires a 14-day cooldown via `prepare_tron_unfreeze` + `prepare_tron_withdraw_expire_unfreeze`. Returns a preview + opaque handle; …

Build an unsigned LiFi-routed cross-chain bridge with TRON as the source chain. User signs a TRON tx via Ledger over USB; the bridge protocol delivers tokens on the destination (any EVM chain or Solana) after the source confirms (typically 1-15 min). LiFi aggregates NearIntents, Wormhole, Allbridge, etc. The builder (1) decodes the TRON protobuf to extract the TriggerSmartContract envelope, (2) asserts the contract_address is the LiFi Diamond on TRON (TU3ymitEKCWQFtASkEeHaPb8NfZcJtCHLt) and the owner_address is the user's wallet, (3) decodes the inner ABI calldata's BridgeData tuple and cross-…

Build an unsigned TRON native TRX send transaction via TronGrid's /wallet/createtransaction. Returns a human-readable preview + opaque handle. Forward the handle via `send_transaction` to sign on the directly-connected Ledger (USB HID via @ledgerhq/hw-app-trx) and broadcast to TronGrid. Run `pair_ledger_tron` once per session first so the TRON app is open and the device address is verified.

Build an unsigned TRC-20 transfer transaction (canonical set only: USDT, USDC, USDD, TUSD) via TronGrid's /wallet/triggersmartcontract. Decimals are resolved from the canonical table — unknown TRC-20s are rejected with an explicit error. Default fee_limit is 100 TRX (TronLink/Ledger Live default); override with `feeLimitTrx` if energy pricing has moved. Returns a preview + opaque handle. Forward via `send_transaction` for USB-HID signing on the paired Ledger. USDT renders natively on the TRON app; other TRC-20s may display raw hex on-device (the contract address and amount are still shown, so …

Build an unsigned TRC-20 approve(spender, amount) tx — sets allowance so a third party can pull tokens via transferFrom. Primary use: authorize the LiFi Diamond on TRON (TU3ymitEKCWQFtASkEeHaPb8NfZcJtCHLt) before running prepare_tron_lifi_swap with a TRC-20 source token (LiFi's quote response assumes the approve already exists; insufficient allowance reverts the swap on-chain). Accepts ANY TRC-20 contract — not just the canonical set. Decimals are auto-resolved for canonical USDT/USDC/USDD/TUSD; for any other TRC-20 you MUST pass `decimals` explicitly. We REFUSE to default decimals on approve …

Build an unsigned TRON Stake 2.0 UnfreezeBalanceV2 transaction — begins the 14-day cooldown on a previously-frozen slice. The `amount` must not exceed what's currently frozen for that resource (query `get_tron_staking` first; TronGrid rejects otherwise with 'less than frozen balance'). After 14 days the slice shows up in `pendingUnfreezes` with an elapsed `unlockAt`; call `prepare_tron_withdraw_expire_unfreeze` to sweep it back to liquid TRX. Returns a preview + opaque handle; forward via `send_transaction` for USB-HID signing on the paired Ledger.

Build an unsigned TRON VoteWitnessContract transaction — casts votes for Super Representatives to earn voting rewards on frozen TRX. IMPORTANT: VoteWitness REPLACES the wallet's entire prior vote allocation atomically. Pass every SR you intend to back (not just a delta); an empty `votes` array clears all votes. Sum of `count` values must not exceed the wallet's available TRON Power — check `list_tron_witnesses(address)` → `availableVotes` first. `count` is an integer (1 vote = 1 TRX of TRON Power). Rewards accrue per block and are harvested via `prepare_tron_claim_rewards` (24h cooldown). Retu…

Build an unsigned TRON WithdrawExpireUnfreeze transaction — sweeps every matured unfreeze slice (those whose 14-day cooldown elapsed) back to liquid TRX. No amount needed; the chain drains all eligible slices in one call. Inspect `pendingUnfreezes` from `get_tron_staking` first — if every entry's `unlockAt` is still in the future, TronGrid returns 'no expire unfreeze' and this tool errors. Returns a preview + opaque handle; forward via `send_transaction` for USB-HID signing on the paired Ledger.

Prepare a direct Uniswap V3 swap (bypasses LiFi aggregator). Use this ONLY when the user explicitly asks for Uniswap — otherwise default to `prepare_swap` which compares routes across venues. Same-chain only (Uniswap V3 is not a bridge). Auto-picks the best pool fee tier (100/500/3000/10000 bps) by quoting all four against QuoterV2 and choosing the one with the best price; pass `feeTier` to override. Supports ERC-20 <-> ERC-20, native-in (ETH -> ERC-20), and native-out (ERC-20 -> ETH). Both exact-in and exact-out. Returns an unsigned tx (with a reset+approve chain when the router needs allowan…

Build an unsigned Uniswap V3 LP burn transaction — destroys the position NFT (irreversible). Hard-refuses unless the position is fully drained: `liquidity == 0` AND `tokensOwed{0,1} == 0`. Standard close-out sequence: `prepare_uniswap_v3_decrease_liquidity({ liquidityPct: 100 })` → `prepare_uniswap_v3_collect` → `prepare_uniswap_v3_burn`. The error message names the right next step on each refusal.

Build an unsigned Uniswap V3 LP collect transaction — harvests every token the position is owed (decreased liquidity from prior `prepare_uniswap_v3_decrease_liquidity` calls + accrued swap fees) up to uint128.max per side. Hard-refuses when the tokenId is not owned by `wallet`. The protocol auto-settles uncollected fee growth into `tokensOwed` inside the call, so even a position with `tokensOwed{0,1}=0` may receive tokens. `recipient` defaults to the wallet; pass an address to send the harvest elsewhere.

Build an unsigned Uniswap V3 LP decreaseLiquidity transaction — removes liquidity from an existing position by tokenId. Pass `liquidityPct: 100` for a full close-out (typical follow-up: `prepare_uniswap_v3_collect`, then optionally `prepare_uniswap_v3_burn`). Pass `liquidity: "<raw>"` for exact-amount accounting; the two args are mutually exclusive. Hard-refuses when the tokenId is not owned by `wallet` (would credit the actual owner) and when the position has zero liquidity (nothing to decrease). **Withdrawn tokens become `tokensOwed` on the position — they do NOT move to the wallet until you…

Build an unsigned Uniswap V3 LP increaseLiquidity transaction — adds liquidity to an existing position identified by `tokenId`. Reads the position's (token0, token1, fee, tickLower, tickUpper) on-chain via positions(tokenId), so the caller only supplies the tokenId + amounts. Hard-refuses when the tokenId is not owned by `wallet` (the on-chain call would still succeed and route the deposit into someone else's position — the position owner gets the new liquidity). Use `get_lp_positions` to enumerate the wallet's tokenIds. Up to two ERC-20 approvals are chained ahead of the increaseLiquidity() c…

Build an unsigned Uniswap V3 LP mint transaction — opens a new concentrated-liquidity position on the (tokenA, tokenB, feeTier) pool, bounded by [tickLower, tickUpper]. Up to two ERC-20 approvals are chained ahead of the mint() call (one per nonzero deposit side); USDT-style reset is handled automatically. The pool must already exist (initialized) — refuses with a clear error otherwise. Tick bounds MUST align to the fee tier's tickSpacing (100→1, 500→10, 3000→60, 10000→200); mis-aligned ticks are rejected rather than silently rounded. v1 limitation: only WETH (not native ETH) is supported as a…

Build an unsigned Uniswap V3 LP rebalance transaction — moves a position from its current tick range to a new one in a single multicall. Composes (in order): decreaseLiquidity(100%) + collect + (optional) burn + mint(new range). The position's (token0, token1, fee) carry over; only the tick range changes. **Slippage is independently applied to the close + re-deposit phases** — the effective tolerance against the spot price is roughly 2× the input bps. The description block calls this out explicitly. v1 amount-source: the new mint's amount0Desired/amount1Desired are estimated from the position'…

Build an unsigned WETH → native ETH unwrap transaction via a direct `WETH.withdraw(uint256)` call on the canonical WETH9 contract for the target chain. Supported chains: ethereum, arbitrum, polygon, base, optimism. Pass an explicit decimal amount (e.g. `"0.5"`) or the literal `"max"` to unwrap the full WETH balance. WETH is always 18 decimals. No approval is required — the wallet burns its own balance and receives native ETH back in the same call; the call is cheaper than routing through a DEX/aggregator. Balance is checked pre-build and the call refuses with a clear message if the wallet is s…

EVM-only: finalize an already-prepared transaction for signing by pinning the nonce, EIP-1559 fees (maxFeePerGas, maxPriorityFeePerGas), and gas limit server-side, then computing the EIP-1559 pre-sign RLP hash Ledger will display in blind-sign mode. Returns a LEDGER BLIND-SIGN HASH content block the user reads BEFORE you call send_transaction — the Ledger device prompt blocks the MCP tool call, so the hash must be surfaced now, not after. The pinned tuple is stashed against the handle and forwarded verbatim on send_transaction so the on-device hash is deterministic. If gas conditions drift whi…

Solana-only: finalize a prepared Solana tx for signing by fetching a FRESH recent blockhash, serializing the message bytes, and computing the base58(sha256(...)) Message Hash the Ledger Solana app will display on blind-sign. MUST be called between prepare_solana_* and send_transaction — Solana blockhashes expire after ~150 blocks (~60s), and the prepare → user-approve → broadcast path on a live Ledger routinely runs longer than that. Splitting the blockhash pin off prepare lets the user see-and-match the hash seconds before tapping Approve, with the full ~60s window available for the broadcast…

READ-ONLY — call any view/pure function on any verified-ABI EVM contract. Mirrors Etherscan's "Read Contract" tab and the symmetric counterpart of `prepare_custom_call`. Use for the long tail of on-chain reads no protocol-specific tool covers: OZ AccessControl role members (`getRoleMember(bytes32,uint256)`, `hasRole(bytes32,address)`), governance proposal state, oracle prices, vault share prices, Safe owner enumeration, ERC-1155 balances, etc. ABI source: pass `abi: [...]` inline (preferred when you have the project's published artifact) OR omit it and the tool fetches via Etherscan V2 — refus…

One-time registration of a multi-sig Bitcoin wallet policy with the Ledger BTC app (BIP-388 wallet policies). REQUIREMENTS: Ledger plugged in over USB, device unlocked, the 'Bitcoin' app open on-screen. Constructs a `wsh(sortedmulti(M,@0/**,@1/**,...))` descriptor from the supplied cosigners, verifies the connected Ledger's master fingerprint matches exactly one cosigner slot, calls Ledger's `registerWallet` (the device walks every cosigner xpub fingerprint on-screen for verification — the user MUST confirm each fingerprint matches what they expect, since this is the moment that anchors the po…

Remove a labeled contact. Without `chain`, removes the label from EVERY chain that has it (one device interaction per chain when removing a signed entry). With `chain`, removes only that chain's entry — the label can survive on other chains. The unsigned metadata row (notes / tags) is dropped only when no chain still references the label. Issues CONTACTS_LABEL_NOT_FOUND if neither the signed disk nor the unsigned in-memory store has the label. Issue #428: unsigned-only removals never need a Ledger; mixed labels (signed entry on one chain + unsigned on another) require pairing only for the sign…

File a capability request against the vaultpilot-mcp GitHub repository when the user asks for something this server cannot do (e.g. an unsupported protocol, chain, token, or missing tool). USE ONLY AFTER confirming no existing tool can accomplish the task. By default this returns a pre-filled GitHub issue URL — NO data is transmitted; the user must click through to submit. If the operator has configured VAULTPILOT_FEEDBACK_ENDPOINT, it posts directly to that proxy instead. Rate-limited per install (30s between calls, 3/hour, 10/day, 7-day dedupe on identical summaries). Write clear, actionable…

READ-ONLY — refresh the cached on-chain `txCount` for every paired Bitcoin address under one Ledger account by re-querying the indexer. Pure indexer-side: NO Ledger / USB interaction. Use this after the user has received funds (so a previously-empty cached address now has history) or when the indexer was stale at the original `pair_ledger_btc` scan time. Updates the persisted cache, so subsequent `get_btc_account_balance` reflects the refresh without another rescan. Three-state extend signal: `needsExtend: true` (trailing buffer address on any cached chain has on-chain history — re-run `pair_l…

READ-ONLY — refresh the cached on-chain `txCount` for every paired Litecoin address under one Ledger account by re-querying the indexer. Pure indexer-side: NO Ledger / USB interaction. Use this after the user has received funds (so a previously-empty cached address now has history) or when the indexer was stale at the original `pair_ledger_ltc` scan time. Updates the persisted cache, so subsequent `get_ltc_balance` reflects the refresh without another rescan. Three-state extend signal: `needsExtend: true` (trailing buffer address on any cached chain has on-chain history — re-run `pair_ledger_l…

Resolve an ENS name (e.g. vitalik.eth) to an Ethereum address via mainnet ENS resolver. Returns null if unregistered. SECURITY: ENS resolution is single-sourced through this MCP. The response includes `verificationUrl` (https://app.ens.domains/<name>) and a `singleSourceWarning`. AGENT BEHAVIOR: always surface the verificationUrl and warn the user to cross-check the resolved address in their browser before using it in a send or prepare_* call. Never silently pass the resolved address into a downstream prepare_* tool without first showing the user the address and the verification link.

Resolve a `(chain, symbol)` pair to its canonical contract address + decimals from the curated registry. Supports EVM chains (ethereum, arbitrum, polygon, base, optimism), Solana, and TRON. Surfaces native-vs-bridged ambiguity verbatim — e.g. asking for `USDC` on Arbitrum returns the native Circle USDC contract AND a `hasBridgedVariant` warning with the `USDC.e` legacy-bridged contract in `alternatives[]`, so the agent can offer the user the actual choice instead of silently picking one. Asking for `USDC.e` directly returns the bridged contract with an `isBridgedVariant` warning + the native U…

Reverse-resolve an Ethereum address to its primary ENS name. Returns null if no primary name is set. SECURITY: ENS resolution is single-sourced through this MCP. The response includes `verificationUrl` (https://app.ens.domains/<address>) and a `singleSourceWarning`. AGENT BEHAVIOR: always surface the verificationUrl and warn the user to cross-check the result in their browser before trusting it. Never silently use the resolved name (e.g. as a display label) without first surfacing the verificationUrl — a rogue MCP can return any name string, including names of well-known entities, to build fal…

Revoke a previously-generated read-only share invite by `name`. Marks the issuer-side record as revoked at the current time. Important caveat (Model A): this is issuer-side BOOKKEEPING — it does NOT recall the token already in the recipient's hands. Anyone holding the raw token can still query the listed addresses (chain reads are public regardless of whether the issuer wants the share to continue). Genuine recall requires Model B (hosted enforcement endpoint), deferred. Returns `{ revoked: { id, name, revokedAt } }` on success; refuses if the name is unknown or already revoked.

Forward an already-prepared transaction to the Ledger device for user signing. Routes on the handle's origin: EVM handles (prepare_aave_*, prepare_compound_*, prepare_swap, prepare_native_send, ...) go through Ledger Live via WalletConnect; TRON handles (prepare_tron_*) go through the directly-connected Ledger over USB HID and are broadcast via TronGrid. In both cases the user must review and physically approve the tx on the Ledger screen; this call blocks until the user signs or rejects. EVM handles REQUIRE a prior preview_send(handle) call in the same session — send_transaction reads the pin…

DEMO MODE ONLY — switch the active demo wallet via one of three input shapes. Once a wallet is set, demo mode upgrades from default (signing-class tools refuse) to live mode (prepare_*, simulate_*, preview_send run REAL against the wallet's on-chain state; send_transaction returns a simulation envelope instead of broadcasting). INPUT SHAPES: (1) `{ chain, type }` — per-cell loader. e.g. `{ chain: 'bitcoin', type: 'whale' }` loads ONE address into the BTC slot, leaving evm/solana/tron slots untouched. Multiple per-cell calls accumulate; same chain twice replaces. Chains: evm | solana | tron | b…

Set an Etherscan V2 API key for EVM transaction-history / allowance-enumeration / tx-explanation reads at runtime — no restart required. Takes precedence over ETHERSCAN_API_KEY env var and userConfig. One key works across all 5 supported EVM chains (Ethereum / Arbitrum / Polygon / Base / Optimism) via Etherscan's V2 unified API. Designed for the demo-mode flow where users want to enable tx-history / allowance / explain_tx tools without restarting their MCP client, but works in any mode. INPUT: bare API key only (34-char alphanumeric, e.g. ZQTKPM98R5N4YT8GMTBI3XR2P4HFZNTAYG). Pasting a URL is r…

Set a Helius API key for Solana RPC reads at runtime — no restart required. The server constructs the canonical Helius mainnet URL (`https://mainnet.helius-rpc.com/?api-key=<KEY>`) internally and uses it for every subsequent Solana call until the process restarts. Takes precedence over SOLANA_RPC_URL env var and userConfig. Designed for the demo-mode flow where users want to fix Solana rate-limits without restarting their MCP client, but works in any mode. INPUT: bare API key only (UUID format, 8-4-4-4-12 hex). Pasting a URL is rejected to prevent prompt-injection redirects to malicious endpoi…

Generate a shareable, anonymized JSON snapshot of the user's portfolio STRUCTURE — protocol + asset + percentage of total — with NO addresses, NO absolute USD values, NO transaction hashes. Use this when the user wants to share their setup ("here's my Solana yield-farming strategy") with another VaultPilot user. Pass at least one of `wallet` / `tronAddress` / `solanaAddress` / `bitcoinAddress` / `litecoinAddress`, plus a `name` and optional `description` / `authorLabel` / `riskProfile`. The recipient pastes the returned `jsonString` into their own VaultPilot via `import_strategy` for read-only…

Co-signer flow — adds OUR Ledger signature to a multi-sig PSBT produced by an external initiator (Sparrow / Specter / Caravan / a peer running this server). Looks up the registered wallet by name, decodes the PSBT, validates every input carries a `bip32_derivation` entry for our master fingerprint (defense against being tricked into signing for a foreign tx), forwards to the Ledger device for the on-device output walkthrough (the user MUST verify every output address + amount on-device matches the chat-side verification block before approving), splices our partial signature(s) into the PSBT, r…

Sign a UTF-8 message with a paired Bitcoin address using the Bitcoin Signed Message format (BIP-137). Returns a base64-encoded compact signature with a header byte that matches the address-type convention (legacy / P2SH-wrapped / native segwit) AND `messageSha256` — a lowercase hex SHA-256 of the exact UTF-8 bytes submitted to the device (Inv #8 byte-fingerprint, issue #454). Surface `messageSha256` in the verbatim message-sign block so the user can recompute on a separate device (`printf '%s' '<message>' | sha256sum`) and catch unicode-confusable substitution attacks the Ledger Nano OLED can'…

Sign a UTF-8 message with a paired Litecoin address using the BIP-137 compact-signature scheme (with Litecoin's `\x19Litecoin Signed Message:\n` prefix). Returns the signature plus `messageSha256` — lowercase hex SHA-256 of the exact UTF-8 bytes submitted to the device (Inv #8 byte-fingerprint, issue #454); surface in the verbatim block so the user can recompute on a separate device. Same on-device clear-sign UX as `sign_message_btc`. DRAINER-STRING REFUSAL (issue #454): refuses messages containing value-transfer / authorization markers or explicit drainer templates BEFORE any device interacti…

Simulate the effect of adding or removing collateral, or borrowing/repaying debt on a lending position. Returns the projected health factor and collateral/debt totals. Supports Aave V3 (default), Compound V3 (pass `protocol: "compound-v3"` + `market` Comet address), and Morpho Blue (pass `protocol: "morpho-blue"` + `marketId` bytes32). No transaction is sent.

Run an eth_call against the chain's RPC to simulate a transaction without signing or broadcasting it. Returns `{ ok, returnData?, revertReason? }`. Use this BEFORE prepare_*/send_transaction to verify a contract call does what you expect — e.g. does wrapping ETH by sending to WETH9's fallback succeed, does a custom calldata revert, what selector gets hit. For state-dependent calls (WETH deposit credits msg.sender, ERC-20 transfer debits msg.sender), pass the user's wallet as `from`. Prepared transactions are also re-simulated automatically at send_transaction time — this tool lets the agent ch…

After the on-chain `approveHash` tx has been mined (broadcast via `send_transaction` from the receipt of `prepare_safe_tx_propose` or `prepare_safe_tx_approve`), post the signature to Safe Transaction Service. Verifies on-chain that `approvedHashes(signer, safeTxHash) != 0` first — refuses to post when the underlying approval doesn't exist yet. Auto-detects whether to call `proposeTransaction` (creates a new queue entry — when this server proposed the tx) or `confirmTransaction` (adds a signature to an existing entry — when another client proposed it). Returns the Safe Web UI deep-link so the …

Drop a registered multi-sig wallet from the local cache. The Ledger device retains the policy HMAC indefinitely (no on-device unregister API), so re-registering with the SAME descriptor + cosigners returns the same HMAC the device already has. This tool only forgets the local-disk entry — call it before re-registering with different cosigners under the same name, or to clean up wallets you no longer use. Idempotent: returns `removed: false` when the name isn't registered. No device touch.

Explicit re-verify. Returns one row per requested chain: `{ chain, ok, anchorAddress?, version?, entryCount?, reason?, unsignedEntryCount? }`. Useful for periodic integrity checks or after a suspected tamper event. Does NOT throw on per-chain failure — caller inspects the `results` array. Issue #428: `unsignedEntryCount` is the count of in-memory unsigned entries on this chain (omitted when zero). When a chain has only unsigned entries, `ok: false, reason: "no signed entries on this chain (unsigned-only)", unsignedEntryCount: N` so the agent surfaces the unsigned overlay rather than silently d…

READ-ONLY Secure Element attestation challenge (issue #325 P1). INTENDED behavior: issue a fresh nonce APDU to the device, receive the SE's attestation signature, verify locally against Ledger's published attestation root CA. CURRENT behavior: returns `status: "not-implemented"` with a structured explanation — the actual cryptographic check is gated on live-device research that hasn't happened yet (canonical APDU for current firmware, PEM/DER of Ledger's attestation root CA, signature-verification algorithm). Sibling defenses cover most of the threat surface in the meantime: verify_ledger_firm…

READ-ONLY firmware-pinning check (issue #325 P3). Reads the connected Ledger's Secure Element firmware version + MCU bootloader version + device target_id via the dashboard-level `getDeviceInfo` APDU (CLA=0xE0 INS=0x01), asserts them against a hardcoded canonical manifest covering Nano S Plus / Nano X / Stax / Flex. REQUIRES the device to be in DASHBOARD MODE — no app open. Ask the user to close every Ledger app (return to the dashboard / home menu) before calling. Returns one of: `verified` (firmware in known-good list), `warn` (at or above floor but not in known-good — likely a fresh Ledger …

READ-ONLY codesign verification of the on-disk Ledger Live binary (issue #325 P4). Per-platform: macOS uses `codesign --verify --deep --strict` + Apple Team ID match; Windows uses PowerShell `Get-AuthenticodeSignature` + Subject substring match; Linux verifies the AppImage's embedded PGP signature is present (full key fingerprint pinning is a follow-up). Defaults to the platform's canonical install path; pass `binaryPath` to override (REQUIRED on Linux — no canonical AppImage location). Returns: `verified` (signature valid + matches Ledger), `mismatch` (signed by someone else — likely self-bui…

Independent server-side cross-check of a prepared EVM tx's calldata. Fetches the function signature(s) registered for the 4-byte selector on 4byte.directory (a public registry), re-decodes the calldata via viem against each candidate, and re-encodes to prove the signature describes the exact calldata bytes losslessly. Returns a VerifyDecodeResult whose `summary` field is pre-written for end-user consumption — the orchestrator should relay it verbatim. Status values: `match` (independent decode agrees with local ABI), `mismatch` (function-name disagreement — DO NOT SEND), `no-signature` / `erro…