mcp server

Crank Protocol

Non-custodial DeFi tools for AI agents on Solana: swaps, perps, lending, staking, equities.

Description as published by the maintainer. Source

• version 1.0.0
• archived

archived — The linked repository returns 404. It was deleted, renamed or made private.

What this server can do

178 functions, named and described by the server itself. Parameter names are shown because they say more about what a function does than its name usually does.

approve_proposal(caller_id, approved_by, proposal_id)

Approve a pending PROPOSAL within its TTL, then re-dispatch it (non-custodial control plane, ENG-63e1517a). 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 this again to retry. See ``wallets.approve_proposal``. Required: proposal_id.

asset_classification(symbol, caller_id, token_address)

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 recommendation. Workflow: RISK/COMPLIANCE step -- classify before executing; 'equity' forces geo-gating + per-execution confirm. Pairs with get_disclaimers. See get_trading_workflow.

assign_ticket(caller_id, ticket_id, assigned_to)

Assign a support ticket to a staff user (username or id). Empty -> unassign. Required: ticket_id.

authorize_session_signer(label, caller_id, expires_at, capabilities, signer_pubkey, wallet_address)

Authorize a delegated session signer for an agent wallet (non-custodial). signer_pubkey is a keypair the USER creates and holds -- ONLY its PUBLIC key ever crosses this call (hard rule 1). Once authorized, calls that carry this signer_pubkey are trade-only: the gate rejects any transfer/ withdraw/close-account/authority-change instruction targeting a destination outside the wallet's own accounts (docs/ SESSION_SIGNER_DESIGN.md). capabilities: subset of swap|perp|lend|stake, empty/omitted = full default set. expires_at: optional ISO 8601 hard expiry. Effective on the very next call using this signer_pubkey. On a Lane 2 wallet this raises BROWSER_CONFIRMATION_REQUIRED -- call request_session_signer_authorization instead (ENG-b35851ed): minting a signer is a trust grant and must be owner-approved in the browser, never in-chat. Required: wallet_address, signer_pubkey.

backtest_strategy(asset, params, fee_bps, end_date, caller_id, timeframe, definition, start_date, slippage_bps, strategy_type, slippage_model, wallet_address, initial_capital)

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 tunes the strategy (e.g. {"fast":5,"slow":20} for momentum). For strategy_type="composite" pass the signal-rule ``definition`` (see compose_strategy); the response includes a per-stream signal_coverage honesty report -- streams with partial persisted history are flagged, never silently zero-filled. slippage_model: "fixed" (slippage_bps haircut) or "jupiter_replay" (realised price-impact from the recorded quote corpus). Returns performance metrics (Sharpe/Sortino/Calmar, max drawdown, win rate, profit factor, VaR/CVaR), final equity, and trade + signal counts. Read-only simulation -- no fee, no on-chain action. Workflow: SIMULATE step -- validate a strategy on history before risking capital; run twice (e.g. auto vs long_only) to compare. Poor Sharpe/deep drawdown -> retune or fall back to the yield leg. Feeds get_risk_assessment -> the strategy_*_create tools. See get_trading_workflow. Required: strategy_type, asset, timeframe, start_date, end_date.

bulk_send_social(token, platform, referral, caller_id, recipients, sender_wallet, idempotency_key)

Distribute one token to many X handles in one call (non-custodial, ENG-bfeacb2c). ``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 few UNSIGNED transactions as fit -- the sender signs + broadcasts every returned tx. Each send carries its crank.ing claim link, the bearer ``claim_code`` (returned once, embed per tweet), and the ``transaction_index`` of the tx that funds it. Anti-abuse gated (account age, verified wallet, per-sender daily limit counting the whole batch). platform: x. ``idempotency_key`` (ENG-ac7961aa, optional): a client-generated UUID. Retrying with the same key + same args replays the original result (same claim_codes/links) instead of locking a second batch of escrows. Required: recipients, token, sender_wallet.

cancel_perp_order(ip, venue, verify, order_id, caller_id, jurisdiction, wallet_address, idempotency_key, acknowledge_tier_b, signed_transaction)

Cancel a resting perp order on its venue (non-custodial). ``jurisdiction`` (ENG-27ae391a, gap RAILS-4): cancel is geo-gated too -- see place_perp_order. ``idempotency_key`` (ENG-ac7961aa, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-cancelling the order. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see place_perp_order. A cancel moves no position, so confirming the signature landed IS the verification -- no state re-read is declared. Required: wallet_address, order_id.

check_claim_status(claim_id, caller_id, recipient, sender_wallet)

Sender-facing claim status of a social send (FREE read, ENG-bfeacb2c). 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). Never exposes the claim-code secret.

claim_status(code, caller_id)

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

clone_strategy(caller_id, template_id, wallet_address)

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, MB#13669). Free to clone. Required: template_id, wallet_address.

close_perp_position(ip, venue, verify, caller_id, close_pct, position_id, jurisdiction, pay_in_crank, payment_header, wallet_address, idempotency_key, acknowledge_tier_b, signed_transaction)

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`` (ENG-27ae391a, gap RAILS-4): closes are geo-gated too -- see place_perp_order. ``idempotency_key`` (ENG-ac7961aa, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-closing the position. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see place_perp_order -- re-call with the signed payload and Crank relays it by custody tier and verifies the result. Required: wallet_address, position_id.

compose_strategy(definition)

Validate a composite definition -- returns the normalised definition + validation report. No persist; read = FREE per the fee schedule. Checks: schema, stream existence against the signal catalog, rule-tree depth/size limits, required risk caps, and the anti-gaming rule (a social sentiment/trend_social stream may never be the sole entry trigger). Required: definition.

crank_dependency_status(caller_id)

Protocol dependency compatibility matrix — are we compatible right now? Read-only. Returns per-protocol RED/AMBER/GREEN status (drift, jupiter, kamino, marginfi, marinade, sanctum, raydium), our SDK pin vs latest, last health-probe result, on-chain program slot, next recommended action, and any auto-filed Engaij ticket — plus an overall headline. Maintained by the backend dependency response engine; callable from the morning briefing, dispatch, or ad-hoc.

crank_prompt_health(caller_id)

Dev Process Health — recurring CC friction this week vs resolved. Read-only. Returns the latest weekly close-report review snapshot (ENG-dc453c0d): a ``Prompt health: N recurring issues, M resolved this week`` headline plus per-issue week-over-week trend (``trending_down_after_fix``) for a dashboard widget. Surfaced in the Monday morning briefing under "Dev Process Health". ``available=False`` until the first weekly review runs.

create_agent_wallet(agent_id, caller_id, display_name, owner_address, wallet_address, default_policies)

Register an agent wallet the caller controls (non-custodial control plane). Creates an AgentWallet record keyed by agent_id and applies an optional default policy preset. default_policies: conservative | balanced | aggressive. wallet_address is the agent's PUBLIC key (caller-supplied); omit it to create a pending record the Turnkey provisioning ticket fills in. Returns wallet_address, agent_id, status, and the applied_policies. Required: agent_id.

create_execution_intent(ip, amount, caller_id, input_token, jurisdiction, output_token, pay_in_crank, slippage_bps, wallet_address, idempotency_key, allow_unverified)

Create a propose-only execution intent; returns an approval URL to hand to the user. Lane 1 (non-custodial default): builds the unsigned swap transaction server-side, persists it as an intent, and returns {intent_id, approval_url}. NOTHING executes until the user opens the approval URL in their browser and signs with their own wallet. This tool never signs and never sees a key. amount is in input-token base units. The quote includes the technology service fee. After the user approves, poll get_intent_status and report ONLY the persisted on-chain state (CONFIRMED before any success claim). FEE PARITY (ENG-8f3fb6d6, follow-up to ENG-254cf6b4/ENG-5a051af4): the on-chain technology service fee baked into the unsigned tx is now resolved through the SAME discount-aware pipeline as ``jupiter_swap`` -- the tokenized-security classification is resolved ONCE here via the authoritative registry-backed classifier (parity with ``jupiter_swap``'s call site) and, together with ``pay_in_crank``, determines the quoted ``platformFeeBps``. Without this an intent proposed via this Lane 1 rail could be fee-classified differently from the identical swap executed via ``jupiter_swap``. Decision: ``pay_in_crank`` IS exposed here (not just ``is_security``) -- the fee rate is a quote-time input baked into the unsigned tx before the user ever reaches the approve page, so an agent must be able to request the pay-in-$CRANK discount at proposal time, same as it can on the direct swap path. GEO GATE (ENG-185ad857, gap RAILS-3): when either leg is a tokenized security this call is geo-gated (Reg S = no US persons) and OFAC-screened, same control ``jupiter_swap``/``trade_equity`` enforce -- ``jurisdiction`` declares the caller's jurisdiction once, ``ip`` is the caller's origin IP for the Reg-S IP layer. Required: input_token, output_token, amount, wallet_address.

declare_jurisdiction(ip, caller_id, jurisdiction, wallet_address)

Declare your wallet's jurisdiction for geo-gated trading (ENG-27ae391a). Gap RAILS-4 (ENG-23f0e18a): 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/short/leverage/trade_equity tool) and the declaration is remembered for 90 days across EVERY geo-gated framework (tokenized equities under Reg S, perps/synthetic-shorting/leverage under the CFTC posture). ``jurisdiction`` is an ISO-3166-1 alpha-2 country code (e.g. "US", "GB", "SG") -- YOUR OWN self-declaration of where you are, never advice or a recommendation (hard rules 2/5-8). A US-person declaration does not unblock US-restricted venues; it makes the DENIED reason explicit rather than "jurisdiction_unknown". Re-declaring overwrites the prior value. Required: wallet_address, jurisdiction.

delete_webhook(caller_id, webhook_id, wallet_address)

Delete one of a wallet's webhook subscriptions (free control-plane write). Required: wallet_address, webhook_id.

detect_regime(asset, caller_id, timeframe, lookback_candles)

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. asset is a token mint; timeframe one of 1m/5m/15m/1h/4h/1d. A description + suggestion only -- not financial advice, not a trade instruction (DYOR). No wallet, no fee, no on-chain action. Workflow: INTELLIGENCE step -- pair with get_market_briefing (macro) + get_ml_signal (forecast); feeds strategy choice + direction_mode at backtest + create time. bear + allow_short -> consider a short. See get_trading_workflow. Required: asset.

discover_agents(limit, caller_id, capability)

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.

discover_strategies(sort, limit, caller_id, strategy_type)

Browse published strategies (read-only, free). Crypto-only (MB#13761). 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).

enable_agent_wallet(agent_id, caller_id, display_name)

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 status is no longer "pending". Required: agent_id.

equity_corporate_events(symbol, caller_id)

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. Required: symbol.

equity_market_hours(symbol, caller_id)

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.

equity_markets(caller_id)

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.

equity_positions(caller_id, wallet_address)

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). Required: wallet_address.

equity_quote(side, amount, symbol, caller_id, venue_hint, slippage_bps)

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`` (ENG-fc290438/ENG-00ebde90, MB#18215) is ADVISORY, never required -- see trade_equity. Required: symbol, amount.

flash_loan(token, amount, caller_id, instructions, pay_in_crank, payment_header, wallet_address, idempotency_key, allow_unverified, marginfi_account)

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. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-issuing the flash loan tx. Required: token, amount, instructions, wallet_address, marginfi_account.

fund_wallet(currency, caller_id, amount_usd, pay_in_crank, payment_header, payment_method, wallet_address, idempotency_key)

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`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result (same checkout_url/session_id) instead of creating a second MoonPay session. Required: wallet_address, amount_usd.

get_agent_profile(caller_id, wallet_address)

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

get_all_venues_status(caller_id)

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.

get_arb_discrepancies(assets, caller_id, window_hours, min_spread_bps)

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, decision-support only -- ignores fees, slippage, and transfer latency; never an execution instruction. Not financial advice. Workflow: INTELLIGENCE step -- pair with get_cross_exchange for the current live-ish read on a specific asset.

get_balances(caller_id, wallet_address)

Wallet token balances (SOL + all SPL tokens) with USD valuations. Workflow: ORIENT step -- the starting read for any flow. See get_trading_workflow. Required: wallet_address.

get_collective_insights(asset, detail, caller_id, insight_type, strategy_type)

Fleet-wide collective insights, historical performance data (free read). Filters: asset (mint/symbol), strategy_type, insight_type (one of param_performance/signal_effectiveness/timing/venue_quality/crowding/ regime_conditional). Only ACTIVE, non-suppressed/non-expired insights are ever returned. Each insight carries n (contributing agents, DP- released), effect_size, a confidence interval, epsilon_spent (privacy metadata -- weigh a high-epsilon insight more cautiously), crowding_index, and staleness (age vs half-life). detail=concise adds a rendered human-readable statement; detail=full adds the raw statement_template/params/signal_keys. Every response is historical collective performance data aggregated across the Crank agent fleet -- descriptive only, never a recommendation or a promise of results. Workflow: INTELLIGENCE step -- fleet-wide context alongside get_market_briefing / get_consensus before sizing or creating strategies.

get_consensus(asset, caller_id, window_hours, payment_header, wallet_address)

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 historical hit-rate (get_source_accuracy). High agreement (>80%) is flagged as a crowded, potentially contrarian condition; low agreement (<30%) as uncertain. This is a PLATINUM-tier feature: covered by a Platinum $CRANK-staker subscription, or pay the per-call x402 fee with payment_header (PAYMENT_REQUIRED otherwise); the billing outcome is in the response ``billing`` field. Descriptive signal only, not a recommendation. Not financial advice. Workflow: INTELLIGENCE step -- pair with get_market_briefing + get_source_accuracy to gauge how crowded a directional read is before sizing. Required: asset.

get_contrarian_signals(asset, caller_id, window_hours, payment_header, wallet_address)

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, returns just that asset's assessment. PLATINUM-tier: covered by a Platinum $CRANK-staker subscription or a verified x402 payment_header (PAYMENT_REQUIRED otherwise); the billing outcome is in ``billing``. Descriptive signal only, not a recommendation. Not financial advice. Workflow: INTELLIGENCE step -- surface crowded trades to fade or uncertain assets to avoid before committing to a regime/allocation.

get_crank_score(caller_id, wallet_address)

A wallet's Crank Score reputation breakdown (FREE read, ENG-95f335be). 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 on-platform activity; circular funding between wallets is flagged + penalised. Well-formed zeros for an unscored wallet. Required: wallet_address.

get_cross_exchange(asset, caller_id, window_minutes)

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; never an execution instruction. Not financial advice. Workflow: INTELLIGENCE step -- pair with get_arb_discrepancies for the persisted, already-debounced episode history. Required: asset.

get_disclaimers(symbol, caller_id, token_address, asset_classification)

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.

get_emerging_patterns(limit, caller_id, min_agents)

k-anonymous emergent fleet behaviour motifs (free read). Returns ordered behaviour motifs -- sequences of (regime, signal_key, action, outcome_sign) steps -- that at least 10 DISTINCT agent cohorts exhibited and that map to NO existing strategy type in the standing taxonomy. Each carries n_agents, a differentially-private aggregate effect_size with a confidence interval, epsilon_spent, and staleness. Filter with min_agents; limit caps the result count (max 100). No wallet address or cohort key is ever returned. Historical collective performance data aggregated across the Crank agent fleet -- descriptive only, never a recommendation or a promise of results. Workflow: INTELLIGENCE step -- see what the fleet is doing that no existing strategy type describes, before designing a new strategy.

get_health_factor(market, protocol, caller_id, wallet_address, marginfi_account)

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

get_ilo_adoption_status(cluster, caller_id)

The ILO adoption gate -- one machine-checkable readiness read (free). Andrew's decision (MB#20076, ENG-5de0ede9): the ILO proceeds only once Crank has 1,000 active users, where an active user has at least 5 executed Crank transactions inside a rolling 7-day window. Signups do not count. Returns gate_met (active_users >= 1000), active_users, near_active_users, users_with_any_tx and the pinned transaction definition. A transaction is an EXECUTED trade only -- a recorded swap (broadcast signature required), a perp open, or a user-initiated perp close; reads, quotes, unexecuted intents, paper trades, liquidations and devnet activity never count. ``cluster=devnet`` exposes the same metric for pre-launch observability; the gate itself is the mainnet number. Aggregate counts only, no per-wallet data. Informational readiness metric; not a promise of any launch, outcome or timeline.

get_indicators(asset, params, lookback, caller_id, timeframe, indicators, include_series)

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 token mint; timeframe one of 1m/5m/15m/1h/4h/1d; indicators selects a subset (empty = all); lookback candles capped at 500; params overrides per indicator, e.g. {"rsi": {"period": 21}}; include_series=true adds per-bar series (last 200 points). Readings are None while history is warming up. Computed readings only -- not financial advice, not a trade instruction (DYOR). No wallet, no fee, no on-chain action. Workflow: INTELLIGENCE step -- raw indicator readings underlying detect_regime; pair with get_ml_signal (forecast) + get_signals (persisted cross-source signals). See get_trading_workflow. Required: asset.

get_integrator_earnings(limit, caller_id, integrator_wallet_address)

Per-action + per-month integrator earnings (onboarding API). Read-only. Required: integrator_wallet_address.

get_integrator_stats(caller_id, integrator_wallet_address)

Integrator dashboard: status, share, onboarded count, earnings breakdown. Read-only. Every figure is fee-share USD (technology service fees the onboarded agents paid), never PnL -- a fee-share, never a performance-share. Required: integrator_wallet_address.

get_intent_status(caller_id, intent_id)

Read the persisted lifecycle state of an execution intent (free read). Returns the server-persisted state only -- CREATED, APPROVED, SUBMITTED, UNKNOWN, CONFIRMED, FAILED, or EXPIRED -- plus the simulation summary and the on-chain signature once submitted. Never infers: UNKNOWN means an unresolved send (may have landed); only CONFIRMED is a verified on-chain success (fail-closed reporting, docs/CRANK_PLUGIN_SPEC.md section 6). Required: intent_id.

get_leaderboard(sort, limit, caller_id, strategy_type)

Top published strategies ranked by a verified backtest metric (free). Crypto-only -- equity templates excluded (MB#13761). 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).

get_lending_rates(caller_id)

Compare supply/borrow rates across Kamino + Marginfi. Each row: protocol, token mint, symbol, supply/borrow APY %, TVL USD, utilization. Workflow: YIELDS step -- the passive-return option for idle/low-conviction capital (lending USDC removes price exposure). Pairs with get_lst_yields. See get_trading_workflow.

get_lst_yields(caller_id)

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.

get_market_briefing(assets, caller_id, timeframe, detail_level, payment_header, wallet_address)

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. ["BTC","SOL"]); for paid tiers it declares the agent's holdings and focuses the synthesis. detail_level: "free" returns the pre-generated daily Free briefing (metered at $0, quota'd per day); "pro" ($0.25) and "platinum" ($0.50) return real-time Sonnet/Opus synthesis personalised to the wallet's portfolio + active strategies. Paid tiers are covered by an active $CRANK-staker subscription or require a verified x402 payment_header (PAYMENT_REQUIRED otherwise). The billing outcome is in the response ``billing`` field. Not financial advice. Workflow: INTELLIGENCE step (usually first) -- macro/sentiment context that frames detect_regime + the allocation. See get_trading_workflow.

get_market_regime(limit, caller_id, window_hours)

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 a strategy type or direction_mode; pair with detect_regime for the asset leg.

get_ml_signal(asset, horizon, caller_id, timeframe, buy_threshold, sell_threshold, lookback_candles)

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), per-model contributions and top feature importances. asset is a token mint; timeframe one of 1m/5m/15m/1h/4h/1d; horizon is the forward-return label horizon in candles. On spot, 'short' = exit-to-flat (no native short). Heuristic forecast from price history only -- not financial advice. No wallet, no fee, no on-chain action. Workflow: INTELLIGENCE step -- a directional forecast that complements detect_regime; low confidence -> cut size or stay flat. See get_trading_workflow. Required: asset.

get_my_contribution_score(epoch, caller_id, wallet_address)

Your own hive contribution score for a monthly epoch (free read). Wallet-scoped -- returns ONLY your wallet's own row, never another wallet's score and never a fleet ranking. ``epoch`` is "YYYY-MM" and defaults to the most recently completed month. Contribution quality = marginal_uplift (how much your journaled decisions tightened the fleet's collective estimates) x outcome_quality (how well your stated expectations matched on-chain-verified outcomes) x novelty (how much your contributions differ from everything else in the pool -- copies score near zero). ``flags`` explains a zero score, e.g. below the activation threshold or no on-chain-verified outcome. Any recognition of contribution quality from the Community Rewards Pool is discretionary, retroactive and effort-gated -- never a yield, a return, an earn-rate, or a promise of a future allocation. Workflow: REVIEW step -- read alongside get_my_performance to see how your journalling habits, not just your P&L, land with the network. Required: wallet_address.

get_my_performance(group_by, caller_id, window_hours, wallet_address)

Your own realised performance, grouped (free read). Aggregates your journaled non-paper outcomes: win rate, total/average realised P&L (USD), and technology-service-fee drag, grouped by strategy_type | asset | decision_type | hour_of_day over window_hours. Includes a calibration score (your stated expectations vs the realised 24h move) when you journal expectations. Historical performance data about your own decisions -- descriptive only, not a recommendation. Workflow: ORIENT step -- read this before sizing or creating strategies. Required: wallet_address.

get_onramp_status(caller_id, session_id)

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

get_ooda_status(caller_id, recent_limit, wallet_address)

Wake-on-condition consent + usage status (ENG-8c57afc3). 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 (ENG-574a0e66/ENG-d7bc9d28): kill_threshold_enabled, kill_threshold_ratio, kill_window_days, and -- if this wallet was auto-killed -- kill_switched_at and kill_reason, so a wallet can see why wakes stopped. Workflow: status/observe step -- check this to see whether the background worker is watching, and what it did (or skipped) recently. Required: wallet_address.

get_portfolio_charter(caller_id, wallet_address)

Read the wallet's active portfolio charter -- the CRANK.md-equivalent mandate (free read). A user-authored document declaring objectives, risk_band, banned tokens, target_allocations, max_position_pct, rebalance cadence, and an escalation webhook -- loaded once per session instead of forgotten between calls (competitors return raw JSON per call and forget everything). has_charter is False when the wallet has not set one yet -- call set_portfolio_charter to create it. Descriptive framing only ("objectives"/"parameters", never return targets, hard rules 5-8). Workflow: ORIENT step 0 -- read this FIRST, before get_balances / portfolio_snapshot, so every downstream decision is framed by it. Required: wallet_address.

get_quests(caller_id, wallet_address)

Live Crank Score quests + a wallet's progress (FREE read, ENG-b0150c40). 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``.

get_quotes(amount, caller_id, venue_hint, input_token, output_token, pay_in_crank, slippage_bps, wallet_address)

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`` (ENG-fc290438/ENG-00ebde90, MB#18215) is ADVISORY, never required -- see jupiter_swap. Pass ``wallet_address`` (optional, ENG-5a051af4) to preview the DISCOUNTED technology service fee that wallet will actually pay -- its volume tier plus $CRANK staker / ``pay_in_crank`` / Crank Score discounts. Omit it for the base rate. This stays a free read either way. Required: input_token, output_token, amount.

get_regulatory_updates(agency, caller_id, window_hours, min_relevance)

Recent regulatory statements affecting Crank's scope (free read, ENG-43ba5e83). 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 ``topics``, and a one-line factual ``summary``; results are ranked by relevance then recency. window_hours bounds the lookback (default 168 = 7 days, capped at 720 = 30 days); min_relevance filters by floor (high/medium/low); agency optionally narrows to one body (SEC, CFTC, FinCEN). Relevance is a compliance-triage signal, not legal advice. Not financial advice. Workflow: INTELLIGENCE / COMPLIANCE step -- check the current regulatory posture around perps, tokenized equities, or agent trading before acting on a strategy.

get_risk_assessment(asset, equity, caller_id, timeframe, strategy_type, lookback_candles)

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 against ``equity``), a per-regime action note, and the full guard set. strategy_type is one of the 16 Crank strategy types; asset is a token mint; timeframe one of 1m/5m/15m/1h/4h/1d. A mechanical, non-personalised calculation you choose whether to act on (DYOR) -- not financial advice, not a recommendation, and not a managed account. No wallet, no fee. Workflow: RISK step -- after backtest_strategy, before execution. The returned suggested_size_usd caps the order in the execute phase; do NOT exceed it. Check asset_classification first (equity -> per-execution confirm). See get_trading_workflow. Required: strategy_type, asset.

get_score(caller_id, wallet_address)

User-facing Crank Score: rank, multiplier, metrics + quests (FREE, ENG-b0150c40). 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`` with progress. Points come ONLY from costly actions (anti-farm). ``disclaimer``: score MAY inform a future token distribution -- no fixed conversion ratio, no entitlement. Required: wallet_address.

get_score_leaderboard(limit, caller_id)

Top-N Crank Score leaderboard (FREE read, ENG-b0150c40). 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.)

get_signal_effectiveness(window, caller_id, signal_type, source_type)

Fleet action-conditioned signal effectiveness (free read). Filters: source_type (e.g. youtube/rss/api/on_chain), signal_type, window (24h|7d|30d|90d|all). Returns, per matching signal_effectiveness collective insight, the fleet action taken, effect_size, confidence interval, contributing-agent count n (DP-released), crowding_index, and staleness. Historical collective performance data aggregated across the fleet -- descriptive only, never a recommendation or a promise of results. Workflow: INTELLIGENCE step -- weigh a signal by how the FLEET's actions on it have historically resolved, alongside your own get_source_accuracy / get_my_performance track record.

get_signals(tier, limit, subject, caller_id, min_score, risk_level, signal_type, include_expired)

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) / ``risk_level`` (none..critical) / ``min_score`` narrow the feed. Unknown filter values are dropped, not errored. Descriptive observed data only -- never a trade instruction. Not financial advice. Workflow: INTELLIGENCE step -- pair with get_market_briefing (macro) and get_token_risk_assessment (per-token safety roll-up) before sizing.

get_social_sends(caller_id, wallet_address)

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

get_source_accuracy(windows, caller_id, source_type)

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, correct/incorrect counts, and accuracy_pct; sources with no resolved calls yet are omitted, and results are ranked by longest-window accuracy. windows optionally narrows the periods (subset of [7,30,90]); source_type optionally filters by source kind (youtube, rss, api, on_chain). Accuracy = the directional call vs the realised Birdeye price over the prediction window. Past accuracy is not a guarantee. Not financial advice. Workflow: INTELLIGENCE step -- pair with get_market_briefing to discount or trust a signal by its source's track record before sizing a position.

get_source_weights(caller_id)

Source-effectiveness weight table (free read; ENG-bfb7ace4). 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 k-anonymous insights, and the combined weighted value the composite effectiveness_weighted transform consumes. Historical grading statistics only -- descriptive, never advice. Not financial advice. Workflow: COMPOSE step -- read alongside list_signal_catalog to pick streams with a real graded track record before authoring a definition.

get_strategy_evolution_report(limit, caller_id, strategy_type)

Clone-marketplace live performance deltas + approvals (free read). Per published template: its live clone-fleet performance payload (average profit and loss in bps across M distinct cloning wallets over the trailing 30 days, differentially private, self-clones excluded), the change vs the previous refresh, and the approval trail for templates that came through the propose-and-approve governance path. A template without enough live clone history reports available=false with a reason -- never a number computed from too few wallets. Draft proposals are never included. Historical data only -- descriptive, never a recommendation or a promise of results. Workflow: INTELLIGENCE step -- compare marketplace templates on OBSERVED live clone history before cloning one via clone_strategy.

get_strategy_leaderboard(window, caller_id, strategy_type)

Anonymized fleet strategy-parameter leaderboard (free read). Ranks param_performance collective insights by effect_size within window (24h|7d|30d|90d|all). NEVER identifies a wallet or cohort -- rankings are anonymized param-bucket aggregates only, and any bucket with fewer than 25 contributing cohorts (the k-anonymity granular floor) is dropped before it ever reaches this response. Historical collective performance data -- descriptive only, never a recommendation or a promise of results. Workflow: INTELLIGENCE step -- compare a strategy_type's own parameter choices against fleet-wide observed outcomes before adjusting via suggest_parameter_adjustment / the strategy tools.

get_strategy_suggestions(asset, limit, status, caller_id)

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 tools (your wallet policy and the engine's risk / conflict / guardrail gates still apply), or approve it in the app. ``status`` filters proposed|approved|dismissed|executed|expired|all. Informational descriptions of observed data only. Not financial advice. Workflow: INTELLIGENCE -> DECIDE step -- review suggestions, then pair with backtest_strategy + get_risk_assessment before any create call.

get_support_dashboard(caller_id)

Support desk metrics: open count, avg response/resolution time, breakdowns. Read-only. Returns totals, open/resolved/unassigned counts, resolution rate, avg first-response + resolution seconds, by-status/category/priority maps, and a 14-day created-ticket trend. Mirrors the backoffice dashboard.

get_support_ticket(caller_id, ticket_id)

Full support-ticket detail with the conversation thread. Read-only. ticket_id: numeric id or human ticket number (e.g. CRK-AB2K9P). Required: ticket_id.

get_technology_updates(category, caller_id, window_hours, min_relevance)

Recent technology / tooling developments relevant to Crank + Engaij (free read, ENG-565c74a9). 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 parent automation platform). Each update carries ``category`` (sdk_release / api_change / competitor / regulatory / research / tooling), ``relevance_to_crank`` and ``relevance_to_engaij`` (high/medium/low/none), a concrete ``application_recommendation`` (what to do about it), title, url, and a one-line ``summary``; results are ranked by relevance then recency. window_hours bounds the lookback (default 168 = 7 days, capped at 720 = 30 days); min_relevance filters by floor (high/medium/low); category optionally narrows to one kind. A triage signal, not advice. Not financial advice. Workflow: INTELLIGENCE step -- scan for SDK / API releases, competitor moves, or tooling worth adopting before planning integration or strategy work.

get_token_classification(caller_id, mint_or_symbol)

Standardised tokenized-stock classification for a mint or symbol (ENG-b34b5493). 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_verified_at. FAIL-SAFE: a registered but unscored token, an inactive token, or an unregistered token reports tradeable=false. trade_equity enforces this same composite risk. Required: mint_or_symbol.

get_token_risk_assessment(limit, subject, caller_id, window_hours)

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). Descriptive observed data only. Not financial advice. Workflow: INTELLIGENCE / RISK step -- run before quoting or sizing an unfamiliar token; a critical safety signal is a hard skip condition. Required: subject.

get_trading_workflow(caller_id, wallet_address)

Map of how Crank's tools fit into one end-to-end trading flow (read this first). Read-only, free. Returns an ordered, machine-readable workflow: orient -> intelligence -> yields -> simulate (backtest) -> risk-size -> execute (non-custodial) -> monitor -> journal. Each step names the concrete tool(s) to call, their purpose, key inputs, how to use the output downstream, and the decision points that branch the flow -- so an agent that discovered Crank via tools/list can sequence the full tool surface instead of guessing. Descriptive only (DYOR); only execute-phase tools are value-bearing. wallet_address (optional, PUBLIC key only -- non-custodial): when given, appends ``human_activity`` -- count + most-recent manual override on this shared account in the last 72h (decision_type, asset, rationale summary, timestamp) plus an instruction to reconcile with it before acting. Human and agents act on ONE account: every human action is journaled (see journal_query source="human") so it is never invisible to you. Absent/clean (``{"count": 0}``) when there is no override.

get_transaction_history(limit, caller_id, wallet_address)

Recent transactions for a wallet, parsed + human-readable (limit 1-100). Required: wallet_address.

get_usage_report(period, caller_id, wallet_address)

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). Required: wallet_address.

get_venue_health(venue, caller_id)

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) -- run before any perps/lending leg; degraded/down reroutes or blocks the order. See get_trading_workflow. Required: venue.

get_venue_risk_score(venue, caller_id)

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. Required: venue.

get_venue_status(caller_id)

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.

go_live_status(caller_id)

Live go-live posture + S1-S6 runbook stage readout (ENG-88a87e5d). The single documented gated config surface (MB#20378 D2, follow-up to ENG-b936ca31): renders the ENTIRE go-live flip state -- cluster, RPC host (bare hostname, never an api key or query string), paper-trading + soft- launch guards, both technology-service-fee rails (x402 + Jupiter swap fee), MoonPay environment, and multi-venue perps posture -- read fresh from config on every call (an admin can flip an env var and the very next call reflects it, no redeploy needed). ``stages`` is an ordered S1-S6 readout of the go-live runbook derived purely from that posture, each ``{stage, label, satisfied, blocking}`` -- the primary verification instrument for every runbook stage (verify-runtime-behaviour-not-config). FREE read, never gated (never in x402 PAID_TOOLS): booleans/counts/hosts only, no secret ever leaves this tool.

journal_append(asset, caller_id, rationale, session_id, signal_ids, strategy_id, expectations, tx_signature, decision_type, suggestion_id, wallet_address, client_platform, idempotency_key, intended_action)

Record a decision in your private, wallet-scoped journal (free write). Your durable memory on Crank: rationale, intended action, and optional expectations (e.g. {"direction": "up", "horizon": "24h"}) are stored as one opaque body only you can read back; the system later attributes realised P&L from on-chain-verified fills and marks prices at 1h/24h/7d/30d horizons. idempotency_key makes replays safe (offline queues / batch agents). Link evidence via signal_ids / suggestion_id / strategy_id (your own strategies only). Autonomous strategy executions are journaled for you automatically -- use this to add the agent-authored layer on top. ``tx_signature`` (optional, ENG-9975a2a8/ENG-791a262d): pass the signature a swap/perp/lend/stake tool just returned to link this decision to its verified on-chain fill -- the proof the Layer 2 contribution firewall needs. Unknown signature for this wallet -> 404. If omitted, the wallet's most recent CONFIRMED transaction within a short window is auto-linked as a best-effort fallback -- explicit is still more reliable, pass it whenever you have it. Workflow: DECIDE step -- journal before (or as) you act; query it back with journal_query / get_my_performance. Required: wallet_address, decision_type, rationale.

journal_query(asset, limit, detail, source, caller_id, outcome_sign, window_hours, decision_type, strategy_type, wallet_address)

Read your own decision journal, most recent first (free read). Wallet-scoped: only decisions journaled for wallet_address are ever returned. Filters: window_hours (0 = all), decision_type, strategy_type, asset (mint/symbol as journaled), outcome_sign (positive|negative|zero on realised P&L), source (agent|system|human -- pass source="human" to see only a manual override on this shared account: human and agents act on ONE account, and every human action is journaled so agents can see and reconcile with it). Every returned row carries its source. detail=concise returns id/type/timestamp/pnl rows (token-budget friendly); detail=full adds bodies, evidence refs, and full outcome marks. Workflow: ORIENT step -- recall what you decided (and what a human may have overridden) before deciding again. Required: wallet_address.

jupiter_swap(ip, amount, verify, caller_id, venue_hint, input_token, jurisdiction, output_token, pay_in_crank, slippage_bps, payment_header, wallet_address, idempotency_key, allow_unverified, signed_transaction)

Execute a token swap via Jupiter (non-custodial). Without signed_transaction: returns an UNSIGNED base64 transaction for your wallet to sign + broadcast. With signed_transaction: broadcasts the caller-signed tx and returns tx_signature. amount is in base units of input_token. Includes the Crank technology service fee when a referral fee account is configured -- collected ON-CHAIN via Jupiter's platformFeeBps (MB#13601), deducted from swap output. Swaps are NOT additionally gated by x402 (ENG-1521ec28: that would double-charge the same fee), so payment_header stays a no-op here (jupiter_swap is not in x402 PAID_TOOLS). pay_in_crank is NO LONGER a no-op (ENG-5a051af4): the on-chain rate is now derived from this wallet's volume tier and $CRANK staker / pay-in-$CRANK / Crank Score discounts, so a discounted wallet is quoted a lower platformFeeBps -- the same schedule x402 applies to perps/lend/stake. SECURITY: the output_token is run through multi-layer authenticity verification before any tx is built; an unverified/suspicious/fake token is blocked (UNVERIFIED_TOKEN). Set allow_unverified=true to trade an unverified token at your own risk (hard scam signals are never overridable). ``venue_hint`` (ENG-fc290438/ENG-00ebde90, MB#18215) is ADVISORY, never required -- spot routes via Jupiter aggregation (the only spot venue today); an unknown hint raises, omitting it is unchanged from before. Workflow: EXECUTE step -- deploy the directional/allocation leg after the risk phase capped the size. Non-custodial. Get a price first with get_quotes. See get_trading_workflow. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying the SAME call (build or broadcast) with the same key + same args replays the original result instead of re-executing -- guards against a timeout-then-retry double-swap. Reuse the SAME key across the build call and its signed_transaction broadcast retry (they dedupe independently); a NEW key means a genuinely new swap. ``verify`` (ENG-df8afe93, default True): when broadcasting (signed_transaction supplied), await on-chain confirmation and re-read the output_token balance -- the response gains a ``verification`` block ({confirmed, slot, post_state, expected_vs_actual}). Gate follow-on decisions on ``verification.confirmed``, never on tx_signature alone. Set False to skip for latency-sensitive callers. Verify any prior signature later with the standalone ``verify_transaction`` tool. GEO GATE (ENG-185ad857, gap RAILS-3): when either leg is a tokenized security this call is geo-gated (Reg S = no US persons) and OFAC-screened, same control ``trade_equity`` enforces -- ``jurisdiction`` declares the caller's jurisdiction once (persisted for next time), ``ip`` is the caller's origin IP for the additional Reg-S IP layer. Non-security swaps are unaffected. Required: input_token, output_token, amount, wallet_address.

kill_wallet(caller_id, wallet_address)

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.) Required: wallet_address.

lend_borrow(amount, market, verify, protocol, caller_id, borrow_token, pay_in_crank, payment_header, wallet_address, idempotency_key, allow_unverified, collateral_token, marginfi_account, signed_transaction)

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`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-borrowing. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see lend_deposit -- re-call with the signed tx and Crank broadcasts it, confirms it on-chain, and re-reads the borrowed balance + obligation health. Required: protocol, collateral_token, borrow_token, amount, wallet_address.

lend_deposit(token, amount, market, verify, protocol, caller_id, venue_hint, pay_in_crank, payment_header, wallet_address, idempotency_key, allow_unverified, marginfi_account, signed_transaction)

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-verified first; set allow_unverified=true to supply an unverified token at own risk. ``venue_hint`` / auto-route (ENG-a01f7fd6): pass ``protocol="auto"`` (or ``""``) -- optionally with ``venue_hint`` as an advisory alias, same naming as jupiter_swap/trade_equity -- to route through the SAME primary+fallback health-failover the internal earn/lending trade bridge already applies (ENG-fc290438): an empty rate snapshot on the primary protocol fails over to the configured fallback. Extends this tool instead of adding a separate earn_quote/trade_earn surface, so lend_deposit is now the one first-class MCP path for both a pinned protocol and an auto-routed deposit. A router-resolved call also carries the smart-contract counterparty-risk disclosure in the response (``disclosures``), matching the internal bridge. Workflow: EXECUTE step (yield leg) -- supply idle stables/tokens after comparing get_lending_rates; monitor with get_health_factor. See get_trading_workflow. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-depositing. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): re-call this tool with the SIGNED base64 tx and Crank broadcasts it, then awaits on-chain confirmation and re-reads BOTH the deposited token's balance and the obligation's health -- the response carries a real ``verification`` block ({confirmed, slot, post_state, expected_vs_actual}). Gate follow-on borrowing on ``verification.confirmed``, never on tx_signature alone. verify=false skips only the confirmation wait. When the build leg auto-routed (protocol="auto"), pass back the SAME resolved ``protocol`` the build response reported -- re-resolving from "auto"/ venue_hint again on the completion leg could pick a different venue if health changed between calls. Required: protocol, token, amount, wallet_address.

lend_repay(token, amount, market, verify, protocol, caller_id, pay_in_crank, payment_header, wallet_address, idempotency_key, marginfi_account, signed_transaction)

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`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-repaying. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see lend_deposit -- re-call with the signed tx and Crank broadcasts it, confirms it on-chain, and re-reads the repaid balance + obligation health. Required: protocol, token, amount, wallet_address.

leverage_close(ip, market, caller_id, position_id, jurisdiction, pay_in_crank, slippage_bps, payment_header, wallet_address, idempotency_key, marginfi_account)

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`` (ENG-27ae391a, gap RAILS-4): closes are geo-gated too -- see short_open. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-unwinding the position. Required: position_id, wallet_address.

leverage_long(ip, token, amount, market, protocol, caller_id, jurisdiction, pay_in_crank, slippage_bps, stable_token, payment_header, wallet_address, idempotency_key, target_leverage, allow_unverified, marginfi_account)

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 payment_header is required. ``jurisdiction`` (ENG-27ae391a, gap RAILS-4): leverage is geo-gated too -- see short_open. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the leveraged position. Required: token, amount, target_leverage, wallet_address.

liquid_stake(amount, verify, protocol, caller_id, pay_in_crank, payment_header, wallet_address, idempotency_key, allow_unverified, signed_transaction)

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 comparing get_lst_yields. Non-custodial. Monitor via portfolio_snapshot. See get_trading_workflow. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-staking. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): re-call this tool with the SIGNED base64 tx and Crank broadcasts it, then awaits on-chain confirmation and re-reads the LST + SOL balances -- the response carries a real ``verification`` block ({confirmed, slot, post_state, expected_vs_actual}). Gate follow-on decisions on ``verification.confirmed``, never on tx_signature alone. verify=false skips only the confirmation wait. Required: protocol, amount, wallet_address.

list_alerts(limit, caller_id, wallet_address, include_triggered)

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 history). limit caps at 200. Workflow: MONITOR step -- read before arming another alert so you do not duplicate a level that is already watched. Pairs with set_alert. See get_trading_workflow. Required: wallet_address.

list_session_signers(caller_id, wallet_address)

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

list_signal_catalog(caller_id, include_inactive)

Catalog of every available signal stream (free read; ENG-5029a312). 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 evaluation count + correct rate) and a gameability class (social streams rank high -- they carry anti-gaming caps). Descriptive historical data only. Not financial advice. Workflow: COMPOSE step -- enumerate streams before authoring a composite strategy definition; pair with get_signals to inspect a stream's feed.

list_support_tickets(limit, search, status, category, priority, caller_id)

List/filter Crank support tickets (newest first). Read-only. Filters (all optional): status (open|in_progress|waiting_on_user|resolved| closed), priority (low|normal|high|urgent), category (billing|technical| feature_request|general), search (matches ticket number/subject/requester email+name/wallet). Returns {count, tickets[]}.

list_turnkey_drift_backlog(limit, caller_id)

The known pre-ENG-5d4d7f01 Turnkey drift backlog. Wallets with a Turnkey sub-org whose enclave policy has never been confirmed synced (``turnkey_policy_synced_at`` NULL) -- provisioned before the re-push fix landed. Read-only triage list; drive reconcile_turnkey_policy(wallet_address, repair=True) per wallet.

list_webhooks(caller_id, wallet_address)

List a wallet's webhook subscriptions (free read; secrets are never returned). Required: wallet_address.

lst_swap(amount, to_lst, verify, from_lst, caller_id, pay_in_crank, payment_header, wallet_address, idempotency_key, allow_unverified, signed_transaction)

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 risk. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-swapping. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see liquid_stake -- re-call with the signed tx and Crank broadcasts it, confirms it on-chain, and re-reads both LST balances. Required: from_lst, to_lst, amount, wallet_address.

note_create(body, caller_id, ticket_id, sender_name)

Append an internal-only note to a support ticket (ENG-69d5785b). Agent-side context: records an internal SupportMessage (is_internal_note=True) that is NEVER emailed to the requester, and leaves the ticket status unchanged. ticket_id: numeric id or human ticket number (e.g. CRK-AB2K9P). Required: ticket_id, body.

offramp_to_fiat(token, amount, caller_id, destination, pay_in_crank, payment_header, wallet_address, idempotency_key)

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`` (ENG-ac7961aa, optional): a client-generated UUID. Retrying with the same key + same args replays the original result (same offramp_id) instead of creating a second MoonPay sell order. Required: wallet_address, token, amount, destination.

perp_close(ip, market, verify, caller_id, close_pct, position_id, jurisdiction, pay_in_crank, payment_header, wallet_address, idempotency_key, signed_transaction)

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`` (ENG-27ae391a, gap RAILS-4): closes are geo-gated too -- see perp_open_long. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-closing the position. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see perp_open_long -- re-call with the signed tx and Crank broadcasts it, confirms it on-chain, and re-reads the position. Required: wallet_address, market.

perp_funding_rates(market, period, caller_id)

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

perp_funding_rates_all(venue, market, caller_id)

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

perp_markets(caller_id)

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

perp_markets_all(venue, caller_id)

Perp markets across venues (venue=None aggregates all routable venues).

perp_modify(ip, new_sl, new_tp, order_id, caller_id, jurisdiction, new_leverage, pay_in_crank, add_collateral, payment_header, wallet_address, idempotency_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`` (ENG-27ae391a, gap RAILS-4): modify (changes leverage/ exposure) is geo-gated too -- see perp_open_long. ``idempotency_key`` (ENG-ac7961aa, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-modifying the order. Required: wallet_address, order_id.

perp_open_long(ip, market, verify, leverage, size_usd, caller_id, jurisdiction, pay_in_crank, payment_header, wallet_address, idempotency_key, stop_loss_price, allow_unverified, take_profit_price, signed_transaction)

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 the daily free tier (x402 payment_header). ``jurisdiction`` (ENG-27ae391a, gap RAILS-4): your ISO-3166-1 alpha-2 country code, self-declared -- perps are geo-gated (CFTC posture: no US persons, unknown jurisdiction DENIED). Pass it once here (or via ``declare_jurisdiction``/``trade_equity``) and it is remembered for 90 days; every perps/short/leverage call is denied until declared. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the position. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): re-call this tool with the SIGNED base64 tx and Crank broadcasts it, then awaits on-chain confirmation and re-reads the perp position -- the response carries a real ``verification`` block ({confirmed, slot, post_state, expected_vs_actual}). Gate follow-on decisions on ``verification.confirmed``, never on tx_signature alone. verify=false skips only the confirmation wait. Required: wallet_address, market, size_usd, leverage.

perp_open_short(ip, market, verify, leverage, size_usd, caller_id, jurisdiction, pay_in_crank, payment_header, wallet_address, idempotency_key, stop_loss_price, allow_unverified, take_profit_price, signed_transaction)

Open a leveraged SHORT perp position on Drift (non-custodial). Same envelope as perp_open_long, opposite direction. ``jurisdiction`` (ENG-27ae391a, gap RAILS-4), ``idempotency_key`` (ENG-7ded4fb8, optional) and ``signed_transaction``/``verify`` (ENG-dc70e40b, two-phase execution): see perp_open_long. Required: wallet_address, market, size_usd, leverage.

perp_positions(caller_id, wallet_address)

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. Required: wallet_address.

perp_positions_all(venue, caller_id, wallet_address)

Open perp positions for a wallet. venue=None aggregates across venues. Each position carries its venue + custody_tier. Required: wallet_address.

place_perp_order(ip, side, venue, market, verify, leverage, size_usd, caller_id, order_type, limit_price, jurisdiction, pay_in_crank, payment_header, wallet_address, idempotency_key, stop_loss_price, take_profit_price, acknowledge_tier_b, signed_transaction)

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_tier / settlement_token. Tier B (venue-custodied) venues require acknowledge_tier_b=true after reviewing custody_disclosure. Fee charged on size_usd notional past the daily free tier (x402). ``jurisdiction`` (ENG-27ae391a, gap RAILS-4): your ISO-3166-1 alpha-2 country code, self-declared -- perps are geo-gated (no US persons, unknown jurisdiction DENIED). Declare once here (or via ``declare_jurisdiction``/``trade_equity``) and it is remembered 90 days. Workflow: EXECUTE step (leveraged directional leg) -- after get_venue_health / get_venue_risk_score clear the venue and get_risk_assessment caps the size. Monitor via perp_positions. See get_trading_workflow. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the order. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): re-call this tool with the SIGNED payload and Crank relays it by custody tier -- Tier A to Solana RPC, then awaits on-chain confirmation and re-reads the position on the executing venue; Tier B to the venue's own submit endpoint, which returns a venue order id (reported as venue-acknowledged, since it is not an on-chain signature). Gate follow-on decisions on ``verification.confirmed``, never on tx_signature alone. Required: wallet_address, market, side, size_usd, leverage.

poll_agent_wallet_enable(caller_id, device_code)

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. Required: device_code.

poll_session_signer_authorization(caller_id, device_code)

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. Required: device_code.

poll_wallet_policy_loosening(caller_id, device_code)

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. Required: device_code.

portfolio_snapshot(caller_id, wallet_address)

Full portfolio summary: positions, total value, allocation %, 24h change. Persisted as a PortfolioSnapshot for historical tracking. Workflow: ORIENT step -- the denominator for position sizing. Call before intelligence/risk so sizes are net of current holdings. See get_trading_workflow. Required: wallet_address.

propose_allocation(assets, intent, caller_id, timeframe, wallet_address)

Ranked allocation plan: intent + balances + regime + yields + ML signals (free read). One call composes the read-only surfaces an agent would otherwise orchestrate by hand -- lending supply APYs, LST staking yields, the per-asset market regime, and the ML ensemble signal -- into a ranked, intent-shaped plan (conservative | balanced | aggressive). Each directional entry names the exact backtest_strategy args to validate it BEFORE deploying, plus the follow-up tool that would act on it. Descriptive analytics only -- never advice, never a promise of results; nothing is executed. Workflow: INTELLIGENCE/ANALYSIS step -- call after get_market_briefing and before backtest_strategy / get_risk_assessment / strategy_*_create.

propose_template_update(name, caller_id, pattern_id, description)

Propose a DRAFT strategy template from an emerging pattern. PROPOSE-AND-APPROVE ONLY. Creates a draft template that is NOT published, NOT verified and NOT eligible for cloning; an administrator must explicitly approve it before it can appear in the marketplace. This tool can never publish, verify, or modify an existing live template, and never auto-applies anything. pattern_id comes from get_emerging_patterns; only an active (k-cleared, differentially private) pattern may be proposed. Descriptive historical observation -- not a recommendation, not financial advice, and not a promise of future results. Workflow: PROPOSE step -- raise an observed emergent motif for human review; approval and any publication remain a human decision. Required: pattern_id.

publish_strategy(name, anonymous, caller_id, description, strategy_type, backtest_run_id, config_template, performance_summary, author_wallet_address)

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 excluded (MB#13761). Read/control-plane, free. Required: strategy_type, name, config_template.

reconcile_turnkey_policy(repair, caller_id, wallet_address)

Diff the LIVE Turnkey enclave policy against Django's expected policy. Fetches the enclave's active signing policy and re-derives the same expected policy set_wallet_policy would push, then diffs them. ``applicable: false`` for a self-custody wallet (no Turnkey signer). ``repair=False`` (default) only REPORTS drift -- operator-triggered repair is safer than auto-repair given the security implications of a policy re-push. ``repair=True`` re-pushes the expected policy and, on success, stamps the drift-tracking timestamp. Required: wallet_address.

register_agent(contact, version, caller_id, description, a2a_card_url, capabilities, display_name, mcp_endpoint, wallet_address, supported_protocols)

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. Required: wallet_address.

register_integrator(name, agent_id, caller_id, contact_email, wallet_address)

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 via ``set_integrator_share`` (anti-gaming whitelist). Idempotent on ``wallet_address``. Returns the integrator stats. Required: wallet_address.

register_referrer(caller_id, referred_wallet_address, integrator_wallet_address)

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. Required: integrator_wallet_address, referred_wallet_address.

register_webhook(url, secret, caller_id, event_types, wallet_address)

Register (or reactivate) a lifecycle-event webhook for a wallet (free control-plane write). event_types is a non-empty subset of: pre_trade (advisory only, never blocks a trade), post_trade, policy_violation, drawdown_warning, strategy_executed. url is your https(s) receiving endpoint. secret is YOUR OWN HMAC-SHA256 signing secret (8-128 chars) -- Crank never sends or stores platform key material here (hard rule 1); you use it to verify the `X-Crank-Signature` header on every delivered event (see docs/WEBHOOKS.md). Re-registering the same (wallet_address, url) pair updates its event_types/secret and reactivates it if it was auto-disabled after repeated delivery failures. Required: wallet_address, event_types, url, secret.

reply_to_ticket(message, caller_id, ticket_id, sender_name, set_waiting)

Reply to a support ticket — emails the requester (SendGrid) + threads it. Records the outbound message and advances status (open/waiting -> in_progress, or waiting_on_user when set_waiting). The message is persisted even if email delivery fails; the returned ``email_sent`` reflects the delivery attempt. Required: ticket_id, message.

request_session_signer_authorization(label, caller_id, expires_at, capabilities, signer_pubkey, wallet_address)

Open the browser-confirmation handshake to authorize a session signer. Call this when authorize_session_signer refuses with BROWSER_CONFIRMATION_REQUIRED (Lane 2 wallet -- ENG-b35851ed). 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_session_signer_authorization(device_code) once approved. Required: wallet_address, signer_pubkey.

request_wallet_policy_loosening(policies, caller_id, wallet_address)

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. Required: wallet_address, policies.

revoke_session_signer(caller_id, signer_pubkey)

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 (ENG-39ec13bf). Required: signer_pubkey.

send_token_social(token, amount, platform, referral, caller_id, expiry_days, sender_wallet, idempotency_key, allow_unverified, recipient_handle)

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). Whoever presents the code claims the tokens and binds ``referral`` on their first claim. ``expiry_days`` (optional, default 7, range 1-90) sets the claim window; unclaimed tokens are returned to the sender after expiry. Anti-abuse gated: sender account age, verified wallet, per-sender daily limit. platform: x. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result (same claim_code/link) instead of locking a second escrow. Required: recipient_handle, amount, token, sender_wallet.

set_alert(token, caller_id, threshold, alert_type, webhook_url, wallet_address)

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 (ENG-4a5e0443). Workflow: MONITOR step -- arm after executing so a tripped level loops you back to the risk/execute phase. See get_trading_workflow. Required: wallet_address, token, alert_type, threshold.

set_integrator_share(caller_id, share_bps, admin_secret, integrator_wallet_address)

ADMIN-GATED: approve an integrator and set its fee-share (0-20%). Validates ``share_bps`` against the per-leg ceiling (integrator_max_share_bps) AND the combined stacking guard (referral + clone + integrator <= max_total_share_bps, so Crank keeps >=40% of every net fee). A breach is REJECTED, never silently clamped. Setting a share on a PENDING integrator also approves it. Requires a valid ``admin_secret`` (CRANK_ADMIN_SECRET). Required: integrator_wallet_address, share_bps.

set_liquidation_alert(market, protocol, caller_id, threshold, webhook_url, wallet_address, marginfi_account)

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 deteriorating obligation loops you back to repay/de-risk. Pairs with get_health_factor. See get_trading_workflow. Required: wallet_address, protocol, threshold.

set_ooda_consent(opted_in, caller_id, wallet_address, kill_window_days, daily_wake_budget, kill_threshold_ratio, kill_threshold_enabled)

Opt in/out of the wake-on-condition worker (ENG-8c57afc3). Default OFF. When opted in, a triggered alert may run a metered background check (Haiku triage, escalating to Sonnet 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 history including skipped wakes. Usage-vs-fee-revenue kill threshold (ENG-574a0e66/ENG-d7bc9d28): wakes auto-suspend if inference spend over kill_window_days (default 30 days) exceeds kill_threshold_ratio (default "0.5") of attributed fee revenue. kill_threshold_enabled lets you disable the check for this wallet; kill_threshold_ratio is a decimal string. All three are optional -- omit to leave the existing/default value untouched. See get_ooda_status for whether/why a wallet was auto-killed (kill_switched_at, kill_reason). Workflow: consent step -- run once (or to change budget/kill config) before wakes can fire; check get_ooda_status afterward to confirm state. Required: wallet_address, opted_in.

set_permission_mode(mode, caller_id, wallet_address)

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 mutating tool outright, PERMISSION_MODE_BLOCKED) | propose (mutating tools return a PROPOSAL envelope -- proposal_id + params + summary -- instead of executing; approve within the TTL via approve_proposal) | auto_within_policy (execute immediately, still capped by every configured WalletPolicy -- the pre-R9 default). Also settable inline via set_wallet_policy's permission_mode param. The transition is logged as an AgentTransaction audit row. Required: wallet_address, mode.

set_portfolio_charter(cadence, caller_id, risk_band, objectives, banned_tokens, body_markdown, wallet_address, max_position_pct, escalation_webhook, target_allocations)

Write a new version of the wallet's portfolio charter (free control-plane write). Creates a new active version -- the prior version stays in history, never deleted (versioned mandate, not an in-place overwrite). risk_band is one of conservative|balanced|aggressive. banned_tokens merge into AgentWallet.evaluate_trade as an ADDITIONAL deny source alongside WalletPolicy.banned_tokens -- an active WalletPolicy always wins when it is the stricter rule; a charter can never loosen an existing policy, and a conflict comes back in the response's `warnings` (logged server-side, never silently dropped). target_allocations is {token: percent}, must sum to <=100. objectives/cadence are free-form parameters -- never phrase them as return promises (hard rules 5-8). Workflow: ORIENT step 0 -- set once at the start of a relationship with an agent/wallet; strategies read it on every execute_strategy tick (see get_trading_workflow). Required: wallet_address.

set_ticket_priority(priority, caller_id, ticket_id)

Set a support ticket's priority (ENG-69d5785b). priority: low|normal|high|urgent. Metadata-only -- no email, no status change. Required: ticket_id, priority.

set_wallet_policy(policies, caller_id, wallet_address)

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_per_day"} | venue_allowlist {"venues"}. Upserts by policy_type; returns the full updated policy set. (Perp leverage cap is a separate follow-up, ENG-f3aacdf1 -- not a policy_type here.) On a Lane 2 wallet, a change that would LOOSEN a server-enforced default raises BROWSER_CONFIRMATION_REQUIRED -- call request_wallet_policy_loosening instead (ENG-45e5ea07). Required: wallet_address, policies.

short_close(ip, market, short_id, caller_id, jurisdiction, pay_in_crank, slippage_bps, payment_header, wallet_address, buy_with_amount, idempotency_key, marginfi_account)

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`` (ENG-27ae391a, gap RAILS-4): closes are geo-gated too -- see short_open. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-closing the short. Required: short_id, wallet_address.

short_open(ip, market, protocol, caller_id, jurisdiction, pay_in_crank, slippage_bps, borrow_amount, payment_header, token_to_short, wallet_address, idempotency_key, allow_unverified, collateral_token, marginfi_account, collateral_amount)

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 payment_header is required. ``jurisdiction`` (ENG-27ae391a, gap RAILS-4): your ISO-3166-1 alpha-2 country code, self-declared -- synthetic shorting is geo-gated (no US persons, unknown jurisdiction DENIED). Declare once here (or via ``declare_jurisdiction``/``trade_equity``/perps tools) and it is remembered 90 days. ``idempotency_key`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the short. Required: token_to_short, collateral_token, collateral_amount, borrow_amount, wallet_address.

short_status(caller_id, wallet_address)

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

sr_backtest(asset, params, fee_bps, end_date, caller_id, sr_config, timeframe, start_date, slippage_bps, strategy_type, slippage_model, wallet_address, initial_capital)

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_date ISO-8601. Returns the standard performance metrics plus persisted SUPPORT_RESISTANCE signals carrying zone metadata. Read-only simulation -- no fee, no on-chain action, not financial advice (DYOR). Workflow: SIMULATE step -- validate an S/R setup on history before risking capital; feeds get_risk_assessment -> sr_configure_strategy. See get_trading_workflow. Required: asset, timeframe, start_date, end_date.

sr_configure_strategy(caller_id, sr_config, strategy_id, wallet_address)

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 strategy is refused. Strategies without an `sr` block behave exactly as before (back-compat). User/agent-owned configuration only: you own and control the strategy; the platform never exercises discretion (DYOR). No key handling, no fee. Workflow: DECIDE step -- after sr_detect_levels + sr_backtest confirm the level picture, store the tuned config on the strategy. See get_trading_workflow. Required: strategy_id, wallet_address, sr_config.

sr_detect_levels(asset, sources, lookback, caller_id, timeframes, sensitivity, manual_levels, zone_width_bps)

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 default ["1h","4h","1d"]; lookback candles per timeframe (capped at 500); sources subset of swing / pivot / fibonacci / volume_profile / price_impact / manual; sensitivity 0-1 (higher = more zones); zone_width_bps sets the band half-width; manual_levels adds caller-supplied override prices. Returns zones (supports / resistances / pivots with price, band, strength, touches, sources, timeframes) plus liquidity_bands. Computed reference levels only -- not financial advice, not a trade instruction (DYOR). No wallet, no fee, no on-chain action. Workflow: INTELLIGENCE step -- the level picture behind sr_backtest + sr_configure_strategy; pair with get_indicators + detect_regime. See get_trading_workflow. Required: asset.

strategy_arb_create(risk, ema_period, slippage_bps, source_token, target_token, usd_per_trade, wallet_address, exit_spread_pct, entry_spread_pct, interval_seconds)

Create an arb strategy -- cross-venue price-discrepancy convergence (APPROXIMATE). Reads a live cross-venue spread each tick (task-sourced from the Jupiter quote corpus vs on-chain price) or falls back to a transparent PROXY (deviation below a short EMA) when unavailable. Enters when the spread clears ``entry_spread_pct`` and flat; exits when it reverts to ``exit_spread_pct``. The simultaneous two-venue fill is collapsed to one leg (flagged ``approximate``). Market-neutral: no direction params exposed (regime is read directly, not adapted). ``risk``: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_trade.

strategy_basis_trade_create(risk, venue, leverage, min_funding, slippage_bps, target_token, usd_per_trade, wallet_address, funding_lookback, interval_seconds, acknowledge_tier_b)

Create a basis-trade strategy -- funding-harvest perp SHORT leg (APPROXIMATE). Routes the perp leg through the multi-venue VENUE ADAPTER (hard rule 2). A live delta-neutral basis trade is long spot + short perp harvesting funding; this executor opens/manages only the perp SHORT leg (the spot long that makes the book delta-neutral is held separately by the caller) -- flagged ``approximate`` + ``funding_not_modeled`` (funding PnL itself is not simulated live). While funding is favourable (> ``min_funding``) and flat, opens the short sized ``usd_per_trade`` at ``leverage``; closes when funding decays to <= ``min_funding``. Only an asset with a mapped perp market (currently SOL) can open. A Tier B (custodied) venue needs ``acknowledge_tier_b=true``. ``risk``: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_trade.

strategy_cancel(strategy_id, wallet_address)

Stop a strategy (sets status=stopped; it will not be dispatched again). Required: strategy_id, wallet_address.

strategy_composite_create(mode, risk, definition, wallet_address, interval_seconds)

Create a composite strategy from a validated definition. Same non-custodial create path as the other 16 strategy types: the wallet holds its own keys; a wallet without a Turnkey signer receives an unsigned transaction per tick for the owner to sign. ``mode`` defaults to LIVE (recorded on the config; a paper mode annotation is informational until the managed-signing epic lands). Recommended: run compose_strategy + backtest_strategy on the definition FIRST -- historical results are not predictive; DYOR. Required: wallet_address, definition.

strategy_copy_wallet_create(risk, allow_short, usd_per_buy, slippage_bps, source_token, target_token, direction_mode, tracked_wallet, wallet_address, regime_override, size_multiplier, interval_seconds)

Create a copy-wallet strategy -- mirrors a tracked wallet's entries/exits. ``tracked_wallet`` is the Solana address to mirror (its confirmed on-chain buy/sell actions are sourced each tick); ``usd_per_buy`` is the default mirror size (scaled by ``size_multiplier``) applied when the tracked wallet buys. APPROXIMATE: no full per-fill replication (every execution is flagged ``approximate``). ``risk`` / direction params: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_buy.

strategy_dca_create(risk, smart, allow_short, usd_per_buy, slippage_bps, source_token, target_token, direction_mode, wallet_address, regime_override, interval_seconds)

Create a dollar-cost-average strategy buying ``usd_per_buy`` of target each interval. ``risk`` (optional) overrides the safe-default risk limits (ENG-b2c60329): ``max_position_pct`` / ``max_portfolio_exposure_pct`` / ``max_single_loss_pct`` / ``max_drawdown_pct`` / ``max_daily_loss_pct`` (percent; <=0 disables a guard). Direction (ENG-bd44b1b7, optional, all deterministic signals -- DYOR): ``direction_mode`` (auto | long_only | short_only | manual; default auto = follow the market regime, reducing exposure in a bear instead of accumulating), ``allow_short`` (enable real shorts via the Drift perps venue), ``regime_override`` (force bull | bear | range | volatile instead of trusting detection). Workflow: EXECUTE step -- stand up a recurring strategy after backtest_strategy validates it and get_risk_assessment sets the guards; track via strategy_status. An agent wallet without a Turnkey signer = paper-trade (unsigned tx per tick). See get_trading_workflow. Required: wallet_address, target_token, usd_per_buy.

strategy_equity_dca_create(risk, smart, allow_short, usd_per_buy, slippage_bps, source_token, target_token, direction_mode, wallet_address, regime_override, interval_seconds)

Create an equity dollar-cost-average strategy (tokenized equities / xStocks). Shares the DCA executor -- identical mechanics/config to ``strategy_dca_create`` -- tagged ``equity_dca`` because ``target_token`` is expected to be a tokenized-equity mint. SEC posture (ENG-6f4d3513): DCA is a MECHANICAL, user-configured strategy (not discretionary), so it stays autonomous even on a security target -- the per-execution confirmation gate only applies to the discretionary types (momentum / sentiment). Equity classification still drives geo-gating + disclaimers at execution; call asset_classification / get_disclaimers first. ``risk`` / direction params: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_buy.

strategy_hedge_create(risk, trailing, allow_short, entry_price, slippage_bps, source_token, target_token, stop_loss_pct, direction_mode, wallet_address, position_amount, regime_override, take_profit_pct, interval_seconds, trailing_distance_pct)

Create a hedge strategy -- an exit trigger that unwinds a held position. Shares the stop-loss executor -- identical config/mechanics to ``strategy_stoploss_create`` -- framed as an active risk-offset trigger: set ``stop_loss_pct`` / ``trailing`` to shed exposure on an adverse move, or ``take_profit_pct`` to lock in a favourable one. At least one of ``stop_loss_pct`` / ``take_profit_pct`` / ``trailing`` must be set. Required: wallet_address, target_token, position_amount.

strategy_list(wallet_address)

List a wallet's strategies (newest first, capped). Required: wallet_address.

strategy_market_make_create(risk, max_levels, mid_period, slippage_bps, source_token, target_token, usd_per_quote, wallet_address, base_spread_pct, spread_lookback, vol_spread_mult, interval_seconds)

Create a market-make strategy -- two-sided spread capture (APPROXIMATE). No live order book -- SYNTHESISES a spread from realised volatility around a rolling mid: a "filled bid" (price a half-spread below mid) buys, a "filled ask" (above mid) sells (up to held inventory). Market-neutral: PAUSES in a trending (bull/bear) regime instead of adapting direction (a maker gets run over by a directional move) -- read directly inside the executor, so no direction params are exposed here. ``risk``: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_quote.

strategy_modify(risk, reason, allow_short, remove_keys, strategy_id, config_updates, direction_mode, wallet_address, regime_override, interval_seconds, target_allocation)

Edit a running strategy's parameters IN PLACE -- no cancel + recreate. React to a fresh signal by retuning the strategy you already own: the execution history, cost-basis ledger and position state all survive, and there is no window where the strategy is gone. The live executor picks the new config up on its NEXT tick; a tick already in flight finishes against the config it loaded (it writes only runtime state, never config, so the two can never clobber each other). Scoped to the caller's own wallet (hard rule 1 -- non-custodial: this edits a row the owner already controls; nothing here holds keys, signs or moves funds). Args (all optional -- supply at least one): ``config_updates``: strategy-config keys to set, merged over the existing config (e.g. ``{"usd_per_buy": 25, "stop_loss_pct": 0.08}``). ``remove_keys``: config keys to drop back to the executor's default. ``risk``: retune the risk limits -- ``max_position_pct`` / ``max_portfolio_exposure_pct`` / ``max_single_loss_pct`` / ``max_drawdown_pct`` / ``max_daily_loss_pct`` (percent; <=0 disables a single guard). ``direction_mode`` / ``allow_short`` / ``regime_override``: the direction controls from the create tools (deterministic signals -- DYOR). ``target_allocation``: new mint->weight basket (rebalance / vault / yield_farm). ``interval_seconds``: new tick interval, used from the next tick on. ``reason``: free text recorded on the strategy's audit log. REFUSED (returns ``immutable_config_key``): ``target_token`` / ``source_token`` / ``tracked_wallet`` / ``venue`` / composite ``definition``. These define WHAT the strategy trades -- editing them in place would desync the executor's position bookkeeping or strand an open perp leg on the venue it was opened against. Cancel and create a new strategy for those. A STOPPED strategy is final and cannot be modified; a paused one can (the edit does not resume it -- use strategy_resume). The merged config is dry-run through the strategy's executor before it is persisted, so an invalid edit is rejected (``invalid_config``) rather than latching the live strategy into ``error`` on its next tick. Required: strategy_id, wallet_address.

strategy_momentum_create(fast, risk, slow, allow_short, usd_per_buy, slippage_bps, source_token, target_token, direction_mode, wallet_address, regime_override, interval_seconds)

Create a momentum strategy -- fast/slow SMA crossover entry/exit. Buys on a bullish cross (fast SMA > slow SMA), sells on a bearish cross. DISCRETIONARY (SEC framework, ENG-6f4d3513): the model interprets a signal and converts it to a trade, so targeting a tokenized SECURITY forces per-execution user confirmation before the scheduled dispatcher will run a tick (``strategies.tasks.execute_strategy`` requires ``user_confirmed=True``; crypto targets stay fully autonomous). Call asset_classification first. ``risk`` / direction params: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_buy.

strategy_pause(strategy_id, wallet_address)

Manually pause a strategy (status=paused_manual; stops dispatch). Required: strategy_id, wallet_address.

strategy_perp_grid_create(risk, venue, leverage, grid_levels, center_price, slippage_bps, target_token, center_period, range_tighten, usd_per_level, volatile_widen, wallet_address, grid_spacing_pct, interval_seconds, acknowledge_tier_b)

Create a perp-grid strategy -- a ladder of perp LONGS accumulated on dips. Routes through the multi-venue perps VENUE ADAPTER (hard rule 2; Jupiter Perps primary). Around a rolling center price (SMA, or an explicit ``center_price``), each ``grid_spacing_pct`` move below center is one rung; crossing a deeper rung opens a perp long sized ``usd_per_level`` at ``leverage``. PAUSES new rungs in a trending (bull/bear) regime and closes the ladder in a bear (stop the bleed); tightens spacing in range, widens when volatile. Only an asset with a mapped perp market (currently SOL) can open -- see get_venue_status for routable markets. ``venue`` optional (defaults to the configured primary); a Tier B (custodied) venue needs ``acknowledge_tier_b=true`` after reviewing its ``custody_disclosure``. ``risk``: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_level.

strategy_protect_create(risk, trailing, allow_short, entry_price, slippage_bps, source_token, target_token, stop_loss_pct, direction_mode, wallet_address, position_amount, regime_override, take_profit_pct, interval_seconds, trailing_distance_pct)

Create a downside-protection monitor on a held position. Shares the stop-loss executor -- identical config/mechanics to ``strategy_stoploss_create`` -- framed as a pure downside guard. At least one of ``stop_loss_pct`` / ``take_profit_pct`` / ``trailing`` must be set. Required: wallet_address, target_token, position_amount.

strategy_rebalance_create(risk, allow_short, slippage_bps, direction_mode, wallet_address, regime_override, interval_seconds, target_allocation, drift_threshold_pct)

Create a portfolio-rebalance strategy toward ``target_allocation`` (mint->weight). Direction (ENG-bd44b1b7, optional, deterministic signal): ``direction_mode`` / ``allow_short`` / ``regime_override`` -- see ``strategy_dca_create``. Required: wallet_address, target_allocation.

strategy_resume(strategy_id, wallet_address)

Re-enable a paused strategy (manual re-enable after a drawdown pause). The drawdown kill switch (ENG-b2c60329) latches a strategy to ``paused_drawdown`` and requires this explicit owner action to resume; the equity high-water mark is reset so it does not immediately re-trip. Required: strategy_id, wallet_address.

strategy_sentiment_create(risk, allow_short, usd_per_buy, slippage_bps, source_token, target_token, bear_threshold, bull_threshold, direction_mode, wallet_address, regime_override, sentiment_score, interval_seconds)

Create a sentiment strategy -- trades an aggregate sentiment score. Buys when the score is >= ``bull_threshold`` (flat), sells when it is <= ``bear_threshold`` (holding); the neutral band holds. The score is sourced live from market intelligence each tick, or pinned via ``sentiment_score``. DISCRETIONARY (SEC framework, ENG-6f4d3513): targeting a tokenized SECURITY forces per-execution ``user_confirmed`` at execution (crypto stays fully autonomous). Call asset_classification first. ``risk`` / direction params: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_buy.

strategy_snipe_create(risk, lookback, allow_short, usd_per_buy, slippage_bps, source_token, target_token, entry_dip_pct, stop_loss_pct, direction_mode, wallet_address, regime_override, take_profit_pct, interval_seconds)

Create a snipe/scalping strategy -- dip-buy with a fast take-profit/stop exit. Flat: buys ``usd_per_buy`` when price is ``entry_dip_pct`` below the close ``lookback`` ticks ago. Holding: exits on a tight ``take_profit_pct`` OR ``stop_loss_pct`` -- many small round-trips. Runs on a short interval (default 60s) since it reads a per-tick rolling price window that must accumulate ``lookback`` + 1 observations before it can enter. ``risk`` / direction params: see ``strategy_dca_create``. Required: wallet_address, target_token, usd_per_buy.

strategy_status(strategy_id, wallet_address)

Status + last execution of one strategy (scoped to the caller's wallet). Required: strategy_id, wallet_address.

strategy_stoploss_create(risk, trailing, allow_short, entry_price, slippage_bps, source_token, target_token, stop_loss_pct, direction_mode, wallet_address, position_amount, regime_override, take_profit_pct, interval_seconds, trailing_distance_pct)

Create a stop-loss / take-profit / trailing-stop monitor on a held position. ``position_amount`` is base units of ``target_token`` to liquidate on trigger. At least one of ``stop_loss_pct`` / ``take_profit_pct`` / a trailing config should be set (fractions, e.g. 0.15 == 15%). Direction (ENG-bd44b1b7, optional, deterministic signal): ``direction_mode`` / ``allow_short`` / ``regime_override`` -- see ``strategy_dca_create``. Required: wallet_address, target_token, position_amount.

strategy_vault_create(risk, allow_short, slippage_bps, direction_mode, wallet_address, regime_override, interval_seconds, target_allocation, drift_threshold_pct)

Create a vault strategy -- a target-allocation basket held via rebalancing. Shares the rebalance executor -- identical config/mechanics to ``strategy_rebalance_create`` (``target_allocation`` mint->weight, ``drift_threshold_pct``) -- framed as a passive basket rather than an active rebalance loop. No external vault/LP deposit (hard rule 1): the non-custodial swap pipeline only rotates spot holdings toward the target weights. Direction (ENG-bd44b1b7, optional, deterministic signal): ``direction_mode`` / ``allow_short`` / ``regime_override`` -- see ``strategy_dca_create``. Required: wallet_address, target_allocation.

strategy_yield_farm_create(risk, allow_short, slippage_bps, direction_mode, wallet_address, regime_override, interval_seconds, target_allocation, drift_threshold_pct)

Create a yield-farm strategy -- maintains a target basket allocation. Shares the rebalance executor (config identical to ``strategy_rebalance_create``): depositing into an external yield protocol / LP position has no faithful swap-pipeline analogue, so this models a yield farm as keeping a target allocation across the basket via converging rebalance swaps (hard rule 1: the non-custodial pipeline only rotates spot holdings, never deposits externally). Direction (ENG-bd44b1b7, optional, deterministic signal): ``direction_mode`` / ``allow_short`` / ``regime_override`` -- see ``strategy_dca_create``. Required: wallet_address, target_allocation.

suggest_parameter_adjustment(caller_id, strategy_id, wallet_address)

Historical parameter observations for one of YOUR strategies (free read). Compares the strategy's realised outcomes against your other strategies of the same type that ran different parameter values, and returns the observed differences ranked by realised P&L -- historical performance data only, never advice, and nothing is changed by this call (PROPOSE flow: acting on an observation is your call via the strategy tools, where every policy/risk gate still applies). Workflow: ORIENT -> DECIDE step -- review observations, then adjust via strategy tools if YOU decide to. Required: wallet_address, strategy_id.

token_info(symbol, caller_id, token_address)

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 (ENG-4a5e0443).

trade_equity(ip, side, amount, symbol, verify, confirm, caller_id, venue_hint, jurisdiction, pay_in_crank, slippage_bps, payment_header, wallet_address, idempotency_key, allow_unverified, signed_transaction)

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 it returns a quote + disclaimer and does NOT execute (no autonomous equity execution). With confirm=true it returns an UNSIGNED base64 tx to sign + broadcast; pass signed_transaction to broadcast a caller-signed tx. Value-bearing: past the daily free tier an x402 payment_header is required. ip = caller origin IP for the Reg S geo gate (US IP -> refused even with an attestation; an agent's Railway Singapore egress resolves to SG and passes). ``venue_hint`` (ENG-fc290438/ENG-00ebde90, MB#18215) is ADVISORY, never required -- equity routes via the issuer registry (one surface today); an unknown hint raises. ``idempotency_key`` (ENG-7ded4fb8, optional): see jupiter_swap -- same replay-on-retry semantics, same key reused across build + broadcast. ``verify`` (ENG-e932b287, extending ENG-df8afe93, default True): when broadcasting (signed_transaction supplied), await on-chain confirmation and re-read the equity mint balance -- the response gains a ``verification`` block ({confirmed, slot, post_state, expected_vs_actual}). Gate follow-on decisions on ``verification.confirmed``, never on tx_signature alone. Set False to skip for latency-sensitive callers. Verify any prior signature later with the standalone ``verify_transaction`` tool. Required: symbol, side, amount, wallet_address.

unstake_lst(amount, verify, caller_id, lst_token, pay_in_crank, payment_header, wallet_address, idempotency_key, signed_transaction)

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`` (ENG-7ded4fb8, optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-unstaking. ``signed_transaction`` / ``verify`` (ENG-dc70e40b, two-phase execution): see liquid_stake -- re-call with the signed tx and Crank broadcasts it, confirms it on-chain, and re-reads the LST + SOL balances. Required: lst_token, amount, wallet_address.

update_agent_profile(metadata, caller_id, wallet_address)

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

update_ticket_status(status, caller_id, ticket_id)

Set a support ticket's status. status: open|in_progress|waiting_on_user|resolved|closed. Stamps resolved_at on transition into resolved/closed and clears it on reopen. Required: ticket_id, status.

venue_risk_comparison(venue_a, venue_b, caller_id)

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. Required: venue_a, venue_b.

verify_token(symbol, caller_id, token_address)

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 warnings, and the per-layer findings. Call this before swapping into an unfamiliar token (ENG-a39caa6d). Required: token_address.

verify_transaction(mint, market, protocol, caller_id, timeout_s, commitment, tx_signature, wallet_address, marginfi_account)

Verify any prior transaction signature on demand (FREE read). Post-trade verification (ENG-df8afe93, harness spec MB#18289 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`` (+ ``wallet_address``): re-reads the Drift perp position. - ``protocol`` (+ ``wallet_address``, optional ``market`` / ``marginfi_account``): re-reads the lending obligation health. Returns ``{confirmed, slot, commitment, post_state, expected_vs_actual, retry_guidance}``. ``confirmed`` is False (never True) on a timeout -- NEVER treat an unconfirmed/timed-out result as success; ``retry_guidance`` names the next step. Use this after signing + broadcasting a transaction yourself (place_perp_order, lend_deposit/borrow/repay, and every other unsigned-tx tool never broadcast server-side) to confirm it actually landed before treating the position/balance as changed. Required: tx_signature.

verify_treasury_settlement_status(caller_id, since_iso, signatures, expected_usd, signature_limit)

On-chain proof the treasury actually received settled x402 USDC (ENG-fb2a9462). Wires ``services.x402_settlement.verify_treasury_settlement`` (ENG-1be912ac 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 ENG-b936ca31/MB#20378, which intentionally split the on-chain proof logic from this wiring to avoid file collisions across parallel sessions. ``signatures`` is optional: when omitted, this tool pulls recent settled ``X402PaymentRecord.tx_signature`` values itself (via ``django_bridge.recent_x402_signatures``, same window shape as ``reconcile_x402_settlement``) over the last ``since_iso`` window (or all time), capped at ``signature_limit`` to bound RPC round trips -- so a caller does not have to hand-assemble signatures to get a real proof. Pass an explicit ``signatures`` list to check specific settle-tx hashes instead (bypasses the DB lookup entirely). ``verified`` is True only when every checked signature confirms on-chain AND (if ``expected_usd`` is given) the treasury balance covers it -- see the service docstring for the full non-falsely-asserting contract. Raises CONFIG_ERROR if no treasury wallet is configured, UPSTREAM_ERROR (retryable) on an RPC failure -- never a silent ``verified=False``. FREE read (never gated, never in x402 PAID_TOOLS): public addresses/ signatures/balances only, never a key (hard rule 1).

wallet_status(caller_id, wallet_address)

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

Last successful function declaration observed on 2026-08-13. Source: https://mcp.crank.ing/mcp. We list what the server declared; we do not call any of these functions.

Endpoint status observed on 2026-08-13. Source: https://mcp.crank.ing/mcp.

Signals

These are separate measurements of different things. They are deliberately not combined into one score, because a popularity number that mixes website traffic with saves and stars cannot be checked or acted on.

Where to get it

• Repository — https://github.com/engaij/crank
• Website — https://crank.ing
• Remote endpoint (streamable-http) — https://mcp.crank.ing/mcp