Crank Protocol

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

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. ``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.

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 advisory 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). ``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.

Open a leveraged SHORT perp position on Drift (non-custodial). Same envelope as perp_open_long, opposite direction. ``idempotency_key`` (ENG-7ded4fb8, optional): see perp_open_long.

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.

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

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). 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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. Workflow: MONITOR step -- arm after executing so a tripped level loops you back to the risk/execute phase. See get_trading_workflow.

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).

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.

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. Workflow: consent step -- run once (or to change budget) before wakes can fire; check get_ooda_status afterward to confirm state.

Change a managed 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.

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).

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

Configure trading limits and rules on a managed 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).

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. ``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.

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. ``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.

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

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.

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.

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.

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``.

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``.

Stop a strategy (sets status=stopped; it will not be dispatched again).

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 advisory until the managed-signing epic lands). Recommended: run compose_strategy + backtest_strategy on the definition FIRST -- historical results are not predictive; DYOR.

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``.

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 advisory -- 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. A managed wallet without a Turnkey signer = paper-trade (unsigned tx per tick). See get_trading_workflow.

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``.

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.

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

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``.

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 (advisory -- 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 exec…

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``.

Manually pause a strategy (status=paused_manual; stops dispatch).

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``.