Crank Protocol MCP

Execute a token swap via Jupiter (non-custodial). `submit_mode (optional): your execution preference. Omitted/"public" = public-RPC broadcast (default, unchanged). "mev_protected" = the tx is built with a Jito tip you pay (jito_tip_lamports`, default 10,000) and relayed to the Jito block engine as a bundle. Use the same mode on build and broadcast. A failed protected submit returns an error

Verify any prior transaction signature on demand (FREE read). Post-trade verification (harness spec R13): awaits on-chain confirmation of `tx_signature at commitment level (up to timeout_s) and, when a state hint is supplied, re-reads the relevant state to compare against what was expected: - mint (+ wallet_address): re-reads that SPL/SOL token balance. - market (+ `

Read-only Jupiter quote for a token pair (no execution). amount is in base units of input_token. Returns routes, price impact, fees, and estimated output. `venue_hint is ADVISORY, never required -- see jupiter_swap. Pass wallet_address (optional) to preview the DISCOUNTED technology service fee that wallet will actually pay -- its volume tier plus $CRANK staker / pay_in_crank` / Crank

Wallet token balances (SOL + all SPL tokens) with USD valuations. detail="concise" (default) returns total_usd + count + balances trimmed to token/symbol/usd_value (IDs for chaining into e.g. get_quotes); "full" returns every field (amount, price_usd) as before. Workflow: ORIENT step -- the starting read for any flow. See get_trading_workflow.

Full portfolio summary: positions, total value, allocation %, 24h change. Persisted as a PortfolioSnapshot for historical tracking. detail="concise" (default) returns total_value_usd/change_24h_pct/snapshot_id + up to the top 10 positions (token/symbol/usd_value -- IDs for chaining); "full" returns every position with amount/price_usd and the complete allocation_pcts map, as before. Workflow: OR

Create a price/position alert checked every 60s by Celery beat. alert_type: price_above | price_below | position_change. token is a mint address. Optional webhook_url is POSTed when the alert fires. Free (no technology service fee) -- a control-plane write, moves no funds and has no transaction notional. Workflow: MONITOR step -- arm after executing so a tripped level loops you back to the risk

Opt in/out of the wake-on-condition worker. Default OFF. When opted in, a triggered alert may run a metered background check (a fast triage model, escalating to a larger model only if worth a closer look) and propose one action. daily_wake_budget (default 10, 1-500) hard-caps metered wakes per day. The worker never executes -- every proposal is approved in your own wallet. See get_ooda_status for

Wake-on-condition consent + usage status. Returns opted_in, daily_wake_budget, wakes_used_today, skips_today, and recent_wakes -- including SKIPPED_BUDGET / SKIPPED_SPEND_CAP rows, so a skipped wake is exactly as visible as a completed one, never silent. Also returns the usage-vs-fee-revenue kill threshold config and state: kill_threshold_enabled, kill_threshold_ratio, kill_window_days, and -- if

Declare your wallet's jurisdiction for geo-gated trading. Gap: before this tool, the ONLY way to declare a jurisdiction was the `jurisdiction= param on trade_equity -- an agent that only ever used perps/short/leverage tools had no write path at all, and the fail-safe unknown-jurisdiction-DENIED rule permanently refused it. Call this ONCE (or pass jurisdiction=` directly on any perps/sho

List a wallet's alerts -- what is currently armed. Free read. Covers both price/position alerts (set_alert) and health-factor liquidation alerts (set_liquidation_alert) -- one table, told apart by alert_type. Default shows only ARMED alerts (active, not yet triggered) -- exactly the set the Celery evaluators will act on. include_triggered=True adds already- tripped and deactivated alerts (recent

Token metadata, price, liquidity, volume, holder count. Provide token_address (mint) or a known symbol. Merges Helius (metadata) with Birdeye (market data). Free (no technology service fee) -- a read with no transaction notional.

Native (ETH) and ERC-20 balances for an address on an EVM chain. chain defaults to "base". ERC-20 balances are returned only for the contracts named in token_addresses -- an EVM RPC endpoint cannot enumerate a wallet's tokens, and guessing from a fixed list would under-report. Free (no technology service fee) -- a read with no transaction notional.

Indicative price of an ERC-20 token on an EVM chain, quoted via 0x. Priced off routed liquidity (what one whole token sells for against quote_token, USDC by default), not an oracle. Free (no technology service fee) -- a read with no transaction notional.

INDICATIVE swap quote on an EVM chain (pricing and routing only). sell_amount is in the sell token's base units. Returns no transaction and no calldata -- this quote is not executable and cannot be signed. Free (no technology service fee) -- a read with no transaction notional.

Execute a spot swap on an EVM chain (non-custodial, two-phase, OPT-IN). chain must be named explicitly -- nothing routes to an EVM chain by default and a Solana route never fails over onto one. Base only today. Without signed_transaction: returns an UNSIGNED EIP-1559 transaction under 'evm_transaction' (Crank fills nonce, gas and 1559 fees, and re-estimates gas against current state). Sign it wi

Multi-layer authenticity check for a token mint (read-only, no execution). Runs the same five-layer verification the swap/trade tools enforce before building a transaction: registry allow-list, Jupiter verified list, Metaplex metadata authority, minimum liquidity, and token age + holder count. Returns verification_status (verified | unverified | suspicious | blocked), the reasons, non-blocking wa

Recent transactions for a wallet, parsed + human-readable (limit 1-100). detail="concise" (default) trims each row to signature/type/timestamp/ status (signature is the ID to chain into journal_append's tx_signature); "full" adds description, tokens_involved, token_mints, and amount.

Backtest a strategy on historical Solana OHLCV before deploying capital. strategy_type is one of the 17 Crank strategy types (dca, momentum, rebalance, stoploss, protect, snipe, sentiment, vault, yield_farm, hedge, equity_dca, perp_grid, copy_wallet, market_make, arb, basis_trade, composite). asset is a token mint; timeframe one of 1m/5m/15m/1h/4h/1d; start_date/end_date are ISO-8601. params tune

ML ensemble directional forecast for a Solana asset (read-only). Trains the ported Bybit ensemble (XGBoost + RandomForest + NeuralNet + GradientBoost + a candle flow proxy) walk-forward on the last lookback_candles of OHLCV, then returns the blended P(up move) for the latest candle: score in [0,1], confidence (distance from 0.5), direction (long/short/neutral via buy_threshold/sell_threshold), pe

Detect the current market regime for a Solana asset (read-only, deterministic). Classifies the latest candle of recent OHLCV as bull / bear / range / volatile and returns a RegimeSignal: regime, confidence, trend_strength, volatility_percentile, a SUGGESTED direction (long/short/neutral) and position-size fraction (0-1), plus the raw ADX / +DI / -DI / SMA-slope / volume readings for transparency.

Combined regime + risk-guard calculation for a strategy on an asset (read-only). Folds the detected market regime together with the safe-default risk guards (position / exposure / single-loss / drawdown / daily-loss limits) into one deterministic output: a rules-based direction, a conviction-weighted position size already capped to the position guard (in both percent-of-equity and USD notional ag

Full standard technical-indicator set for one asset/timeframe (read-only). Computes sma, ema, macd, adx (+DI/-DI), rsi, stochastic (%K/%D), roc, bollinger (mid/upper/lower/width/%B), atr, keltner, realised_vol, vwap, volume_ratio and volume_profile (POC / value area / high-volume-node liquidity bands with 0-1 depth scores) from recent OHLCV via the canonical backend/indicators library. asset is a

Multi-timeframe support/resistance zones + liquidity bands (read-only). Detects S/R zones per timeframe from recent OHLCV (swing highs/lows, floor pivots, Fibonacci retracement, volume-profile clusters, optional manual levels), merges them across timeframes with a confluence multiplier, and weights zone strength by overlapping candle-volume liquidity-band depth. asset is a token mint; timeframes

Attach an S/R config block to YOUR OWN strategy (ownership-checked). Persists an sr param block (SRConfig knobs: sensitivity, sources, lookback, swing_window, zone_width_bps, merge_tolerance_bps, min_touches, min_strength, max_zones_per_side, manual_levels, liquidity_weight_k) onto the caller's own strategy params. The strategy must belong to wallet_address -- configuring someone else's strateg

Backtest a strategy with an S/R config block (read-only simulation). Runs the existing backtest engine with strategy_type (default "support_resistance": bounce-long off detected support, exit on a support break or resistance-fail; on spot a SHORT signal is exit-to-flat) and merges the validated sr_config into params["sr"]. asset is a token mint; timeframe one of 1m/5m/15m/1h/4h/1d; start_date/end

Classify a token: crypto / equity / wrapped_major / lst / stablecoin. Provide token_address (mint) or a known symbol. Tokenized securities (xStocks, Ondo) classify as 'equity', which subjects strategies to the SEC framework guardrails (neutral tools, per-execution confirmation for discretionary types). Registry-authoritative with a static + symbol fallback. Factual classification only -- not a re

Compliance disclaimers for an asset class (SEC framework). Pass asset_classification (crypto/equity/wrapped_major/lst/stablecoin), or a token_address/symbol to classify first. Equity adds a securities-specific non-registration / not-advice notice. Full text: crank.ing/disclosures.

Open a leveraged LONG perp position on Drift (non-custodial). Returns an UNSIGNED base64 transaction for your wallet to sign + broadcast, plus entry/liquidation/margin estimates. market e.g. SOL-PERP. size_usd is notional USD; leverage up to the market max. TP/SL are informational in the build — place them as trigger orders after the position opens. The fee is charged on size_usd notional past th

Open a leveraged SHORT perp position on Drift (non-custodial). Same envelope as perp_open_long, opposite direction. `jurisdiction, idempotency_key (optional) and signed_transaction/verify` (two-phase execution): see perp_open_long.

Close a perp position, full or partial (non-custodial). close_pct in (0, 100]. Returns an UNSIGNED base64 tx to sign + broadcast, plus exit price + realized P&L estimate (incl funding). Past the daily free tier an x402 payment_header is required. `jurisdiction: closes are geo-gated too -- see perp_open_long. idempotency_key` (optional): a client-generated UUID. Retrying with the same key

Modify an existing open Drift ORDER by order_id (non-custodial). Adjusts trigger price (TP/SL). new_leverage / add_collateral require a separate collateral deposit/withdraw and are recorded for tracking. Returns an UNSIGNED base64 tx to sign + broadcast. Past the daily free tier an x402 payment_header is required. `jurisdiction`: modify (changes leverage/ exposure) is geo-gated too -- see perp

List open perp positions for a wallet with live P&L. Each: market, side, size, entry/mark price, unrealized P&L (incl funding), liquidation price.

Available Drift perp markets with price, open interest, funding, max leverage.

Current funding for a perp market (rate, period, last funding timestamp). market e.g. SOL-PERP. period is informational (1h/8h/24h).

Open a leveraged perp position on the best/selected venue (non-custodial). side is "long" | "short". market e.g. SOL-PERP; size_usd is notional USD. venue optional -- defaults to the configured primary (Jupiter Perps), with health failover to the fallback for new orders. Returns an UNSIGNED tx (Tier A) or a signing payload (Tier B) for your wallet to sign + broadcast, plus venue_name / custody_ti

Close a perp position (full/partial) on its venue (non-custodial). position_id is venue-native (for Drift it is the market symbol). close_pct in (0, 100]. Returns an UNSIGNED tx / signing payload to sign + broadcast. `jurisdiction: closes are geo-gated too -- see place_perp_order. idempotency_key` (optional): a client-generated UUID. Retrying with the same key + same args replays the orig

Cancel a resting perp order on its venue (non-custodial). `jurisdiction: cancel is geo-gated too -- see place_perp_order. idempotency_key (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-cancelling the order. Reuse the SAME key across the build call and its signed_transaction` completion call -- see place_perp_order;

Set, amend or cancel a take profit / stop loss on an ALREADY-OPEN perp position (non-custodial). place_perp_order can attach TP/SL only inline on the order that OPENS a position; this adds one to a position that is already open. Currently supported on Jupiter Perps (position_id = the position pubkey, as returned by perp_positions_all); other venues are refused. At least one of take_profit_price

Open perp positions for a wallet. venue=None aggregates across venues. Each position carries its venue + custody_tier. detail="concise" (default) trims each position to position_id/market/side/size/unrealized_pnl/venue (position_id is the ID to chain into close_perp_position) plus tpsl_triggers -- the TP/SL triggers resting on the position, each with the request_id set_perp_tpsl takes to amend or

Perp markets across venues (venue=None aggregates all routable venues). detail="concise" (default) trims each market to symbol/venue/price/ max_leverage (symbol is the ID to chain into place_perp_order); "full" adds base/quote/custody_tier/min_size/open_interest_usd.

Normalized funding/borrow rates across venues (venue=None aggregates).

Health + capabilities of every perps venue, plus routing config. Reports primary/fallback venue, which venues are routable, per-venue health (operational/degraded/down/disabled), and capability flags incl custody tier.

Live reachability probe against the deployed execution sidecar. Thin wrapper around `sidecar_service.is_configured/healthcheck. Runs the probe from the SERVER's own network path, which a local curl $SIDECAR_URL/health cannot do: that only proves the caller's own shell can reach a sidecar, never whether the deployed mcp.crank.ing server can. Unconfigured (SIDECAR_URL` unset) raises

On-chain proof the treasury actually received settled x402 USDC. Wires `services.x402_settlement.verify_treasury_settlement` ( real on-chain proof: treasury USDC ATA balance read as the primary signal, plus settle-tx signature confirmation) up to an MCP tool -- the follow-up to which intentionally split the on-chain proof logic from this wiring to avoid file collisions across parallel sessions.

Deposit assets to earn yield on Kamino or Marginfi (non-custodial). Returns an UNSIGNED base64 tx to sign + broadcast, plus supply APY. amount is in base units of token. protocol: kamino | marginfi -- pin one to keep exact prior behaviour. Marginfi needs marginfi_account (create via the sidecar). Past the daily free tier an x402 payment_header is required. The deposited token is authenticity-veri

Borrow against deposited collateral (non-custodial). Returns an UNSIGNED base64 tx + current health factor (pre-borrow estimate). amount in base units of borrow_token. Deposit collateral first. Past the daily free tier an x402 payment_header is required. The borrowed token is authenticity-verified first; set allow_unverified=true to borrow an unverified token at your own risk. `idempotency_key

Repay borrowed amount (non-custodial). Returns an UNSIGNED base64 tx + current health factor. amount in base units of token. Past the daily free tier an x402 payment_header is required. `idempotency_key (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-repaying. Reuse the SAME key across the build call and its `signed_transac

Compare supply/borrow rates across Kamino + Marginfi. Each row: protocol, token mint, symbol, supply/borrow APY %, TVL USD, utilization. detail="concise" (default) drops tvl_usd/utilization (token is the ID to chain into lend_deposit); "full" returns every field. Workflow: YIELDS step -- the passive-return option for idle/low-conviction capital (lending USDC removes price exposure). Pairs with g

Liquidation-risk monitor for a lending position. Returns health_factor (>1 safe, <1 liquidatable), collateral value, debt value, liquidation threshold. protocol: kamino | marginfi.

Arm a liquidation alert: notify when a lending obligation's health factor falls to or below threshold. protocol: kamino | marginfi (marginfi_account required for marginfi). threshold is the HF level (e.g. 1.2 warns before the <1.0 liquidation point). Evaluated every 30s by Celery beat; webhook_url is POSTed on trip. Workflow: MONITOR step -- arm after opening a leveraged/borrow position so a det

Marginfi flash loan for arbitrage (non-custodial, atomic). instructions are JSON ix executed between borrow + repay legs. Returns a single UNSIGNED base64 tx that reverts unless repaid in-transaction. The borrowed token is authenticity-verified first; set allow_unverified=true to borrow an unverified mint at your own risk. Past the daily free tier an x402 payment_header is required. ``idempotenc

Stake SOL for a liquid-staking token (non-custodial). amount in lamports. protocol: marinade | jito | blaze. Returns an UNSIGNED base64 tx + the LST received + current APY. The technology service fee is charged on the staked-SOL notional past the daily free tier (x402 payment_header; set pay_in_crank for the $CRANK discount). Workflow: EXECUTE step (yield leg) -- stake the idle slice after compa

Unstake an LST back to SOL (non-custodial). lst_token is a mint (mSOL/jitoSOL/bSOL); amount in base units. mSOL routes via Marinade, others via the Sanctum router. Returns an UNSIGNED base64 tx. The technology service fee is charged on the unstaked-LST notional past the daily free tier (x402 payment_header). `idempotency_key` (optional): a client-generated UUID. Retrying with the same key + sa

Compare APY across LST providers (Marinade/Jito/Blaze) with MEV-boost + validator-count descriptors. Workflow: YIELDS step -- staking keeps SOL exposure + earns yield (vs lending, which removes price exposure). Best APY becomes the 'park it' leg of the allocation; execute via liquid_stake. See get_trading_workflow.

Swap between two LSTs via the Sanctum router (non-custodial). from_lst/to_lst are mints; amount in base units. Returns an UNSIGNED base64 tx + output amount. The technology service fee is charged on the input-LST notional past the daily free tier (x402 payment_header). The acquired LST (to_lst) is authenticity-verified first; set allow_unverified=true to swap into an unverified LST at your own ri

Read a token launch live from chain (free): terms, status, escrow balances, and a machine-readable liquidity release schedule. `launch_id is the on-chain u64 launch identifier. Returns the raise window and progress, the per-wallet pledge cap (0 = uncapped), live escrow + launch-vault balances, and a release_schedule` block (cliff-then-linear) an agent can plan future claim_ilo_tokens calls

Read your own on-chain Pledge record for a launch (free). Returns how much this wallet has pledged, its share of the raise, its remaining headroom under the per-wallet cap, the projected pro-rata allocation, how much the liquidity release schedule has unlocked vs already released, and whether an on-chain refund is available (refunds open only if the raise FAILS its minimum). Workflow: MONITOR st

Pledge to a token launch. PLAN MODE BY DEFAULT (non-custodial). `amount is in pledge-mint BASE UNITS (USDC is 6dp: 1_000_000 = 1 USDC). Default (confirm=false) returns action: "plan"` -- a preview that evaluates every on-chain guard off-chain first (launch status, pledge window, remaining capacity, per-wallet cap) plus the anti-sybil screen and a pro-rata allocation projection. Nothing

Claim the launch tokens your liquidity release schedule has unlocked. Returns an UNSIGNED `release_tokens transaction (action: "sign_required"`) you sign with your own wallet and broadcast yourself. Crank NEVER co-signs a claim -- there is no backend signing path here by design (hard rule 1). When nothing has unlocked yet -- before the cliff, or everything unlocked has already been release

Open a lending-based short: deposit collateral -> borrow token -> sell. Returns an ORDERED STEP PLAN of UNSIGNED base64 txs to sign + broadcast in sequence, plus entry price + health factor + a short_id for tracking. All amounts in base units. The shorted token is authenticity-verified first; set allow_unverified=true to short an unverified mint at your own risk. Past the daily free tier an x402

Close a tracked short: buy token -> repay loan -> withdraw collateral. Returns an ORDERED STEP PLAN + exit price. short_id from short_open. Past the daily free tier an x402 payment_header is required. `jurisdiction: closes are geo-gated too -- see short_open. idempotency_key` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of

List open shorts for a wallet with entry price + health factor.

Open a lending-based leveraged long by looping deposit -> borrow stable -> buy more -> redeposit. Returns an ORDERED STEP PLAN of UNSIGNED base64 txs, effective leverage, loop count, health factor, and a position_id. amount in base units. The levered token is authenticity-verified first; set allow_unverified=true to lever an unverified mint at your own risk. Past the daily free tier an x402 payme

Unwind a tracked leveraged position: sell -> repay stable -> withdraw. Returns an ORDERED STEP PLAN. position_id from leverage_long. Past the daily free tier an x402 payment_header is required. `jurisdiction: closes are geo-gated too -- see short_open. idempotency_key` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-unw

Fund a wallet with fiat via MoonPay (card/bank/Apple Pay -> USDC). Returns a hosted checkout_url for the user to complete payment + a session_id to poll with get_onramp_status. Purchased USDC settles directly to wallet_address (non-custodial). payment_method: card | bank | apple_pay. The fee is charged on amount_usd notional past the daily free tier (x402 payment_header). `idempotency_key` (op

Cash out crypto to fiat via MoonPay (non-custodial). token is the crypto to sell; amount is its quantity; destination is a MoonPay bank_account_id the fiat is paid to. Returns offramp_id, estimated_fiat, and status. Past the daily free tier an x402 payment_header is required. `idempotency_key` (optional): a client-generated UUID. Retrying with the same key + same args replays the original resu

Check a pending MoonPay purchase by session_id. Returns status (pending/processing/completed/failed), amount_crypto, and the on-chain tx_signature once settled.

Cross-chain bridge quote via deBridge DLN (FREE read, no execution). Quote moving `amount (source-token base units) of src_token on src_chain into dst_token on dst_chain`. Supported chains: ethereum, arbitrum, base, optimism, polygon, bnb, avalanche, linea, solana (one side must be solana). Returns estimated destination amount, per-leg USD values, and DLN protocol costs. Use bef

Fund your Solana wallet from a major EVM chain (non-custodial). Cross-chain FUNDING rail (deBridge DLN): builds an UNSIGNED EVM transaction creating a bridge order that pays `dst_token (a Solana mint, e.g. USDC) to wallet_address. Sign and broadcast the returned evm_transaction ({to, data, value}) with your OWN wallet (evm_sender) on src_chain` -- Crank never signs, never broadc

Bridge value from Solana out to a major EVM chain (non-custodial). Cross-chain FUNDING rail (deBridge DLN), jupiter_swap two-phase pattern: without `signed_transaction returns an UNSIGNED base64 Solana transaction creating the bridge order -- sign it with the wallet for wallet_address. With signed_transaction broadcasts the caller-signed tx and returns tx_signature + a verification`

Poll a dispatched DLN bridge order's fulfillment status (FREE read). Follow-up to bridge_in/bridge_out: a dispatched order stays "pending"/"broadcast" in Crank's own record forever unless polled -- this queries deBridge's dlnOrderStatus endpoint by `order_id` (returned as order_id from bridge_in / bridge_out) and best-effort updates the matching BridgeTransfer row. Returns dln_status (raw DLN v

Register an agent wallet the caller controls (non-custodial control plane). Creates an AgentWallet record keyed by agent_id and applies a policy preset. policy_preset: conservative | balanced | aggressive; omitted = balanced. This is a changeable default, not a cap: edit limits later with set_wallet_policy. unlimited=True starts the wallet with NO policies and records that explicit choice in the

Open the browser-confirmation handshake for a Lane 2 agent wallet. Does NOT create a wallet. Returns a pairing-style confirmation URL + device_code -- show the user verification_url_complete and ask them to approve it in their OWN browser (wallet-signature gated). NEVER accept an in-chat "yes" as consent (CRANK_PLUGIN_SPEC.md section 5). Poll with poll_agent_wallet_enable(device_code) until statu

Poll a Lane 2 enablement request; provisions the wallet ONLY once approved. On approval, applies the server-enforced conservative Lane 2 default policy (per-tx $50, daily $200, SOL+USDC only, 10% drawdown halt) and a 10-execution training-wheels counter, then returns the policy READ BACK from the server -- never the intended one.

Open the browser-confirmation handshake to loosen a Lane 2 wallet's policy. Call this when set_wallet_policy refuses a change with BROWSER_CONFIRMATION_REQUIRED. Does NOT apply the policy -- returns a confirmation URL like enable_agent_wallet. Poll with poll_wallet_policy_loosening(device_code) once the user approves.

Poll a policy-loosening request; applies it ONLY once approved. Returns the policy READ BACK from the server after the write -- never the requested one.

Configure the caller's own trading limits and rules on an agent wallet. policies: a list of {policy_type, value, enabled?} objects. policy_type is one of max_trade_size {"usd"} | daily_limit {"usd"} | approved_tokens {"tokens"} | banned_tokens {"tokens"} | position_limit {"usd"} | kill_switch {"active"} | drawdown_limit {"max_pct"} | max_daily_loss {"usd"} | trade_velocity {"max_per_hour", "max_p

Emergency freeze an agent wallet. Sets status=killed so the policy gate refuses every subsequent value-bearing action. Returns confirmation + a frozen-positions count. (Turnkey scoped-key revocation is handled by the deferred provisioning ticket.)

Owner pause of an agent wallet (reversible). Sets status=suspended and pauses its active strategies, so the policy gate refuses every value-bearing action until resume_wallet. Same semantics as the web Agent console pause. Refused on a killed or already-paused wallet.

Owner resume of an owner-paused agent wallet. Lifts only a pause the owner applied (pause_wallet or the web console) -- never an operations or wallet-recovery suspension -- and re-activates only the strategies that pause stopped. Killed wallets stay killed. Requires an owner-authenticated plugin token (wallet_admin scope); refused while a wallet recovery is in progress.

Current state, policy summary, recent activity, total volume, and tier.

Read the per-token trading caps (TradingLimit rows) on an agent wallet. Returns {wallet_address, trading_limits: [{token_address, max_position_size, max_single_trade, daily_volume_limit}], enforcement}. Caps are USD decimal strings; null = uncapped. `enforcement` states which execution rails actually read each column today -- a stored cap is not necessarily a binding one. Sibling of wallet_stat

Configure per-token trading caps (TradingLimit) on the caller's agent wallet. limits: a list of {token_address, max_position_size?, max_single_trade?, daily_volume_limit?} objects, USD amounts (> 0, up to 6 decimals). Upserts by token_address; only the cap keys you include are written -- an omitted key keeps its stored value, an explicit null clears it (uncapped). Returns the full updated set rea

Change an agent wallet's session permission mode (non-custodial control plane). Ports Claude Code's plan/acceptEdits/bypassPermissions ladder to a wallet with signing power. mode: observe (deny every value-bearing tool outright, PERMISSION_MODE_BLOCKED) | propose (value-bearing tools return a PROPOSAL envelope -- proposal_id + params + summary -- instead of executing; approve within the TTL via a

Approve a pending PROPOSAL within its TTL, then re-dispatch it (non-custodial control plane). Flips a propose-mode proposal (see set_permission_mode) from pending to approved, then immediately re-invokes the original deferred tool call (stored `tool_name + params`) through this same dispatch table. On redispatch failure the proposal stays APPROVED (not silently EXECUTED or PENDING) -- call

Opt a wallet into an AGNTA DelegationGrant spend/scope cap (non-custodial control plane). Validates grant_pda decodes as a base58 32-byte address, the on-chain account exists and decodes as a DelegationGrant, it is not revoked and not expired, and its delegate matches wallet_address -- every failure raises INVALID_PARAMS with a distinct message. Adds an ADDITIONAL cap enforced alongside (never re

Remove a wallet's AGNTA DelegationGrant cap opt-in (non-custodial control plane). LOOSENS enforcement (removes a cap constraining every value-bearing call on top of WalletPolicy) -- for a Lane 2 wallet this raises BROWSER_CONFIRMATION_REQUIRED: call request_agnta_grant_clear instead and have the user approve it in their own browser. A non-Lane-2 wallet clears directly.

Open the browser-confirmation handshake to clear a Lane 2 wallet's AGNTA grant cap. Call this when clear_agnta_grant refuses with BROWSER_CONFIRMATION_REQUIRED. Does NOT clear the grant -- returns a confirmation URL like request_wallet_policy_loosening; the wallet's OWNER must approve in their own browser (never in-chat). Poll with poll_agnta_grant_clear(device_code) once approved.

Poll a grant-clear request; clears the AGNTA grant ONLY once approved. Returns {"status": "pending"} while waiting, {"status": "expired"} for an unknown/expired code (never fabricates approval), or on approval clears through the same rails clear_agnta_grant uses for a non-Lane-2 wallet.

Re-enter an AGNTA AgentIdentity binding that has not reached `registered. Branches on SIGNING CAPABILITY, not on a status label: an OWNER / SessionSigner wallet is moved to pending and handed a fresh UNSIGNED register_identity` instruction -- the OWNER signs it with their own wallet (no key material ever reaches Crank, hard rule 1) and then calls submit_agnta_identity_registration, or s

Submit the OWNER-SIGNED `register_identity transaction and complete the binding. Submits the transaction, then VERIFIES on chain before stamping anything: the account at identity_pda must be OWNED by the AGNTA agent-registry program, carry the AgentIdentity discriminator, AND carry this wallet's own authority pubkey. Only then does the wallet move pending -> registered`. A signature

Complete (or re-check) an owner wallet's AgentIdentity binding from chain. The poll half of the handshake: for an owner who signed AND submitted the `register_identity transaction themselves, this is the only call needed. Verifies the on-chain AgentIdentity account exactly as submit_agnta_identity_registration does and stamps registered` only on success; otherwise it returns the wallet's cu

Register/replace/clear the AGNTA counterparty allow-set for the caller's opted-in DelegationGrant (non-custodial control plane). Persists to Django so the set survives an MCP process restart and is visible to every process -- the durable successor to the earlier process-local `InMemoryCounterpartySetResolver. wallet_address must belong to an AgentWallet with a non-blank `agnta_grant_p

Refuses ALWAYS with BROWSER_CONFIRMATION_REQUIRED. Minting (or reactivating) a session signer grants NEW signing authority -- a trust grant at least as sensitive as loosening a policy, which is already browser-gated. This tool therefore refuses EVERY call, for EVERY wallet (not only Lane 2), after validating capabilities for early UX. The only mint path is the browser handshake: request_session_s

Open the browser-confirmation handshake to authorize a session signer. The ONLY way to mint a session signer -- authorize_session_signer always refuses with BROWSER_CONFIRMATION_REQUIRED for every wallet. Does NOT authorize the signer -- returns a confirmation URL like enable_agent_wallet; the wallet's OWNER must approve in their own browser (wallet-signature gated, never in-chat). Poll with poll

Poll a signer-authorization request; authorizes ONLY once approved. Returns {"status": "pending"} while waiting, {"status": "expired"} for an unknown/expired code (never fabricates approval), or on approval binds the signer through the same rails authorize_session_signer uses and returns the created session_signer row.

Instantly revoke a delegated session signer (non-custodial control plane). Single atomic DB UPDATE -- the gate resolves the row fresh on every call with no cache, so this is enforced on the very next call using signer_pubkey. No TTL/cache window.

List all delegated session signers (active + revoked) for a wallet.

Register an agent integrator by its payout wallet -- lands PENDING. The Jupiter-integrator self-serve onboarding step. The profile earns NOTHING until an admin approves it and sets its fee-share (anti-gaming whitelist). Idempotent on `wallet_address`. Returns the integrator stats.

First-touch bind an onboarded agent wallet to an approved integrator. First-touch wins: a wallet already attributed to any integrator keeps that binding. Requires the integrator be approved; rejects a self-referral.

Integrator dashboard: status, share, onboarded count, $CRANK reward state. Read-only. Rewards are $CRANK only: reward_asset, pre_mint and $CRANK buckets (accrued/pending/claimable/paid, each count/priced_count/ amount_base_units). No USD reward figure, never PnL -- a fee-share, never a performance-share.

Per-action + per-month integrator $CRANK reward rows. Read-only. Monthly rollup of earning_events + amount_base_units; recent rows carry crank_amount (null while unpriced). $CRANK only, no USD reward figure.

Live safety/health read for one trading venue (read-only, non-custodial). Returns operational status (live/degraded/suspended), last monitoring heartbeat, on-chain program deploy slot, SDK compatibility headline, TVL + perps 24h volume (DeFiLlama, cached 5 min). venue is a slug e.g. "drift", "jupiter", "pacifica". Use BEFORE routing capital to a venue. Workflow: RISK step (venue-safety gate) --

Composite venue risk score 0-100 (higher = safer), with breakdown. Read-only. Folds custody tier (A self-custodial / B venue-custodied), multisig threshold, timelock, audit status, exploit history, TVL trend and program age into a transparent weighted score (score_breakdown returned so the number is auditable). Factual assessment, not financial advice.

Dashboard overview of all configured venues for routing decisions. Read-only. One health record per active venue (status, deploy slot, TVL, 24h volume, composite safety score) so an agent can pick a venue in a single call. detail="concise" (default) trims each record to venue/ display_name/status/composite_score (venue is the ID to chain into get_venue_health); "full" adds deploy slot, TVL, 24h v

Side-by-side risk comparison of two venues for a routing decision. Read-only. Returns each venue's full risk record, the safer venue, and the composite-score delta. e.g. compare "jupiter" vs "pacifica" before routing.

Spot-trade a tokenized equity (xStocks / Ondo) via Jupiter, non-custodial. side: buy | sell. amount is in base units of the INPUT token (USDC 6dp for a buy, the equity token for a sell). These are tokenized SECURITIES: the call is geo-gated (Reg S = no US persons; declare jurisdiction once via the jurisdiction arg) and OFAC-screened, and requires per-execution confirmation -- WITHOUT confirm=true

List available tokenized equities with issuer, regime, price, market hours. Read-only. Source: the admin-editable TokenRegistry. Each row carries issuer (xStocks/Ondo), regulatory_framework, geo_restrictions, and best-effort price/volume/market-cap, plus NYSE status + the 24/7-on-Solana flag.

Read-only Jupiter quote for a tokenized-equity trade (no execution). amount is in base units of the INPUT token (USDC for buy, the equity for sell). Returns expected output, price impact, effective fee, slippage, and the SEC disclaimer. `venue_hint` is ADVISORY, never required -- see trade_equity.

Tokenized-equity holdings for a wallet with live prices + market hours. Read-only. Filters balances to registered equity mints; each: symbol, quantity, current_price, current_value_usd, issuer, regulatory_framework (avg_cost / unrealized P&L null until cost-basis tracking lands).

Earnings / dividend / split calendar for a tokenized equity. Read-only. The after-hours-agent feature: events an overnight strategy reacts to while the underlying trades 24/7 on Solana. Provider-backed; returns an honest empty payload + SEC EDGAR link when no feed is configured.

NYSE session status + the 24/7-on-Solana availability flag. Read-only. status: closed | pre_market | open | after_hours, with next open/close. Highlights the structural advantage: tokenized equities trade 24/7 on-chain regardless of NYSE hours.

Standardised tokenized-stock classification for a mint or symbol. Read-only. Returns every classification dimension -- backing_status (fully/treasury backed, synthetic, unknown), liquidity_tier (tier_1/2/3 / illiquid, from Jupiter price impact), issuer_verified (Metaplex authority match), market_data_quality (live/stale/none) -- plus the derived composite risk (low/medium/high/blocked) and last_v

Register/refresh an agent's discovery profile in the Crank registry. capabilities is a subset of swap|perps|lending|staking|strategies|signals| equity|onramp; supported_protocols e.g. ["mcp","a2a","x402"]. Idempotent on wallet_address (a PUBLIC key -- non-custodial). This is how other agents find you via the A2A Agent Card + Solana Agent Registry.

Find registered agents, optionally filtered to one capability. capability one of swap|perps|lending|staking|strategies|signals|equity|onramp (empty = all). Ranked by reputation then recency. Read-only, free.

Read an agent's published profile + its referral stats (read-only, free).

Patch an agent profile's metadata (display_name, capabilities, endpoints). metadata is a dict of writable fields; capabilities are validated if present.

Publish a cloneable strategy config to the marketplace (the flywheel). config_template is the parameter set others clone. anonymous=true omits the author. performance_summary is a factual metrics blob -- no return promises are stored or surfaced (hard rule 8). backtest_run_id attaches a verified backtest (on-chain attestation hash + leaderboard ranking). Equity (tokenized-security) strategies are

Browse published strategies (read-only, free). Crypto-only. strategy_type filters to one of the 16 Crank strategy types (empty = all). sort ranks by clones|sharpe|return|sortino|win_rate|drawdown (default clones). detail="concise" (default) trims each entry to template_id/strategy_type/ name/clone_count/is_verified/backtest_hash (template_id is the ID to chain into clone_strategy); "full" adds de

Top published strategies ranked by a verified backtest metric (free). Crypto-only -- equity templates excluded. sort in sharpe|return| sortino|win_rate|drawdown|clones (default sharpe). Each entry carries factual backtest metrics + the on-chain attestation hash; no return promises (rule 8). detail="concise" (default) trims each entry the same way as discover_strategies (template_id is the ID to c

Clone a published strategy config to a wallet (records attribution). Returns the config_template to deploy via the strategy create tools. The clone is attributed to the template author for the clone-creator fee share (15% of the tech fee on clone actions). Free to clone.

Self-report an MCP-registry install/discovery event. Producer for the `registry_install inbound-artifact leg that growth_metrics.organic_integration_candidates already consumes: call this once, with your own stable caller_id`, after your server installs/discovers Crank via an MCP registry listing (Smithery, PulseMCP, the official MCP registry). Writes a synthetic marker row -- moves no

Send tokens to an X handle via a claimable crank.ing link (non-custodial). Locks `amount (base units) of token (mint) from sender_wallet` into the on-chain claim escrow against a fresh claim code, and returns an UNSIGNED base64 transaction for the sender to sign + broadcast, plus the crank.ing/{code} claim link and the claim_code (the bearer secret to embed in the announcement tweet). W

Distribute one token to many X handles in one call (non-custodial). `recipients is a list of {recipient_handle, amount, message?} dicts (recipient accepted as an alias; amount in base units; message an optional per-recipient note). Locks each amount of token (mint) from sender_wallet into a fresh claim escrow and returns the create_claim` instructions batched into as

A wallet's social token sends (newest first; no claim-code secrets).

Public status of a crank.ing claim code (status, amount, claimable, expiry).

A wallet's Crank Score reputation breakdown (FREE read). Returns total_score, per-activity components (trade / staking / strategy / social / claim), sybil_flagged + penalty_bps, and the score-gated perks it unlocks under `gates`: fee_discount_bps (additional technology service fee discount), daily_send_limit (higher social-send cap), priority_access, and the gate tier (0-3). Score accrues from

User-facing Crank Score: rank, multiplier, metrics + quests (FREE). The campaign-layer view on top of `get_crank_score. Returns total_score, leaderboard rank + percentile, the applied multiplier_bps (streak / early-adopter / strategy-creator), the wallet's costly-action metrics (fee_volume_usd, strategies_published, clones_spawned, referrals_activated, active_days), and its live quests`

Top-N Crank Score leaderboard (FREE read). Ranked descending by total_score. `limit caps at the admin-configured leaderboard_size. Each entry: rank, wallet_address, total_score, the base/action/quest components, multiplier_bps, streak_days, percentile. Also returns total_participants and the pre-token disclaimer. (Distinct from get_leaderboard`, which ranks strategy templates.)

Live Crank Score quests + a wallet's progress (FREE read). Time-bounded, admin-configured campaigns (e.g. "Trade $1000 this week = 500 pts"). Each quest carries its tracked costly metric, target_value, reward_points, the active window, and -- when `wallet_address is given -- the wallet's progress_value + completion state. Carries the disclaimer`.

Sender-facing claim status of a social send (FREE read). Look up by `claim_id (the send id) OR recipient (X handle); optionally scope a recipient lookup to one sender_wallet. Returns {"sends": [...]}` each with status (pending/claimed/expired/returned), claim_date, returned_at, recipient_wallet, amount, claim_link, expiry_ts, and expires_in_seconds (a live countdown, 0 once expired)

An agent's own premium-feature spend report (FREE read). Returns per-feature {calls, spend_usd, cost_usd} plus totals from the FeatureUsage ledger. period: today | 7d | 30d | all (default 30d).

The published rate-limit tiers and enforcement contract (FREE read). Limits bind to resolved identity -- the verified pairing token on plugin-v1/agent-v1, the client IP on anonymous surfaces -- so rotating caller_id never resets a bucket. Value-bearing tools additionally consume a separate lower bucket. Exhausted callers get a RATE_LIMITED error envelope with retry_after_seconds; plugin-v1/agent-

Crypto market briefing synthesised from free public sources (tiered). Returns a market briefing aggregated from free crypto data sources (Coin Bureau, DeFiLlama, the alternative.me Fear & Greed index) plus classified sentiment signals: market summary, top movers / most-discussed assets, sentiment regime, the Fear & Greed reading, and source attribution. assets is an optional list of tickers (e.g.

Historical directional hit-rate of each intelligence source (free read). Returns per-source accuracy stats for the intelligence signal sources (Coin Bureau / YouTube, RSS, Fear & Greed API, on-chain), so an agent can weight a source's calls by how often its bullish/bearish reads have played out. Each source carries a `windows` map over rolling 7d/30d/90d periods, each with total resolved calls,

Recent regulatory statements affecting Crank's scope (free read). Returns SEC / CFTC / FinCEN press releases and rule proposals from a scheduled daily scan, LLM-classified for relevance to Crank: DeFi, crypto perps, tokenized equities, autonomous agent trading, and non-custodial custody. Each update carries the issuing `agency, title, url, relevance (high/medium/low) + score, matched `top

Recent technology / tooling developments relevant to Crank + Engaij (free read). Returns items from a scheduled scan of technology feeds (Anthropic, OpenAI, Coinbase Developer, Solana Foundation, Hacker News filtered, GitHub trending) plus flagged YouTube tech channels (full transcript ingested), LLM-classified for relevance to both Crank (Solana trading infra + DeFi frontend) and Engaij (the par

Multi-source consensus + contrarian read for one asset (PLATINUM premium). Cross-references the classified intelligence signals for `asset over the last window_hours` (default 24): how many independent sources agree on direction (consensus_score 0-1), the source breakdown (bullish/bearish/neutral), and the accuracy-weighted directional score (-1..+1) that blends each source's call by its hi

Contrarian (crowded) + uncertain assets across the window (PLATINUM premium). Scans the classified intelligence signals over the last `window_hours and returns assets where source agreement is very high -- a one-sided, crowded positioning flagged as a potential contrarian condition (with the side a contrarian would take) -- and assets where agreement is very low (uncertain). With asset` set

Filtered, most-recent-first feed of structured market signals (free read). The observed-signal data spine: squeeze / flow / technical / microstructure / behavioral / liquidity / safety / whale / regime / macro / oracle / event / composite signals persisted by the collectors. `subject matches a token symbol/market or its stable ref (mint / market address); signal_type / tier (a|b|c) /

Per-token risk roll-up over recently observed safety signals (free read). Folds every non-expired signal for `subject (symbol or mint) in the window into the worst risk level seen, a 0..1 risk score, a per-level count breakdown, and the contributing signals (worst-first). Complements -- does not replace -- get_risk_assessment` (regime + position-size guards for deploying a strategy). Descri

Market-wide regime from the persisted regime/macro signal feed (free read). Returns the dominant regime, its confidence, a distribution across observed regimes, and the contributing signals. For a live per-asset regime computed from OHLCV, use `detect_regime` instead. Descriptive observed data only. Not financial advice. Workflow: INTELLIGENCE step -- market-wide posture check before choosing

Catalog of every available signal stream (free read). One entry per signal source across all tiers -- on-chain collectors, free API sources, derived analyzers and external provider adapters -- with tier, cost-gate state (paid Tier-D gates are fail-closed and disabled by default), coverage window (earliest/latest persisted signal -- the honest backtest window), effectiveness stats (graded evaluati

Source-effectiveness weight table (free read). Per (source, signal_type, regime): graded evaluation counts, the smoothed effectiveness weight (social sources hold a low prior until sufficiently graded -- the anti-gaming cold start), the fleet Layer-2 multiplier from released anonymized fleet insights, and the combined weighted value the composite effectiveness_weighted transform consumes. Histori

Cross-venue snapshot for one asset (free read). Per-venue price/bid/ask/movement (5m/1h/24h change), the pairwise spread matrix (bps), the widest current spread, and -- for wrapped-asset legs (BTC/ETH) only -- the Solana-DEX wrapped-asset premium vs the CEX-consensus reference price. Observed data, decision-support only -- spreads ignore fees, slippage, and cross-venue/bridge transfer latency; ne

Persisted cross-venue discrepancy episodes (free read). Already-debounced `cross_exchange signals (each required >= N consecutive polls above the discrepancy threshold to exist at all), filtered to spread_bps >= min_spread_bps and optionally to assets, within window_hours`. One entry per episode: venue pair, spread, first/last seen, persistence, reference price. Observed data, decis

Signal-to-action suggestions from the synthesis engine (free read, G4). Per-asset directional observations aggregated hourly from the accuracy- weighted intelligence consensus (get_consensus math) plus the Fear & Greed context, each carrying a ready-to-use strategy config. PROPOSE flow: this tool never executes anything -- act on a suggestion by creating the strategy through the normal strategy t