Crank Protocol

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`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-staking. Reuse the SAME key across the build call and its ``signed_transaction`` completion call -- the two legs dedupe independently, so this never raises IDEMPOTENCY_CONFLICT; a NEW key means a genuinely new stake. ``signed_transaction`` / ``verify`` (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.

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.

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

Catalog of every available signal stream (free read). One entry per signal source across all tiers -- on-chain collectors, free API sources, derived analyzers and external provider adapters -- with tier, cost-gate state (paid Tier-D gates are fail-closed and disabled by default), coverage window (earliest/latest persisted signal -- the honest backtest window), effectiveness stats (graded 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 a wallet's webhook subscriptions (free read; secrets are never returned).

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`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-swapping. Reuse the SAME key across the build call and its ``signed_transaction`` completion call -- see liquid_stake; the two legs dedupe independently, so this never raises IDEMPOTENCY_CONFLICT. ``signed_transaction`` / ``verify`` (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.

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

Close a perp position, full or partial (non-custodial). close_pct in (0, 100]. Returns an UNSIGNED base64 tx to sign + broadcast, plus exit price + realized P&L estimate (incl funding). Past the daily free tier an x402 payment_header is required. ``jurisdiction``: closes are geo-gated too -- see perp_open_long. ``idempotency_key`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-closing the position. ``signed_transaction`` / ``verify`` (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.

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

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

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

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

Modify an existing open Drift ORDER by order_id (non-custodial). Adjusts trigger price (TP/SL). new_leverage / add_collateral require a separate collateral deposit/withdraw and are recorded for tracking. Returns an UNSIGNED base64 tx to sign + broadcast. Past the daily free tier an x402 payment_header is required. ``jurisdiction``: modify (changes leverage/ exposure) is geo-gated too -- see perp_open_long. ``idempotency_key`` (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 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``: 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`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the position. Reuse the SAME key across the build call and its ``signed_transaction`` completion call -- the two legs dedupe independently (the completion leg is namespaced under its own storage key, matching jupiter_swap's build/broadcast pattern), so this never raises IDEMPOTENCY_CONFLICT; a NEW key means a genuinely new order. ``signed_transaction`` / ``verify`` (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.

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

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. detail="concise" (default) trims each position to position_id/market/side/size/unrealized_pnl/venue (position_id is the ID to chain into close_perp_position); "full" adds entry_price/current_price/leverage/liquidation_price/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). ``jurisdiction``: 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`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of re-opening the order. Reuse the SAME key across the build call and its ``signed_transaction`` completion call -- the two legs dedupe independently, so this never raises IDEMPOTENCY_CONFLICT; a NEW key means a genuinely new order. ``signed_transaction`` / ``verify`` (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.

Pledge to a token launch. PLAN MODE BY DEFAULT (non-custodial). ``amount`` is in pledge-mint BASE UNITS (USDC is 6dp: 1_000_000 = 1 USDC). Default (``confirm=false``) returns ``action: "plan"`` -- a preview that evaluates every on-chain guard off-chain first (launch status, pledge window, remaining capacity, per-wallet cap) plus the anti-sybil screen and a pro-rata allocation projection. Nothing is built and nothing moves. ``confirm=true`` returns ``action: "sign_required"`` with an UNSIGNED base64 transaction you sign with your own wallet and broadcast yourself. Crank never holds your keys. A pledge is irreversible once broadcast: the on-chain refund path opens only if the raise fails its minimum. Utility token fair launch -- this commits funds to a non-custodial escrow. It is not a purchase of any expectation of profit and confers no claim on issuer revenue. The technology service fee applies past the daily free tier (x402 payment_header; set pay_in_crank for the $CRANK discount). ``idempotency_key`` (optional): a client-generated UUID. Retrying with the same key + same args replays the original result instead of pledging twice. US persons are blocked (Reg S-flavoured geo-posture, I4): declare ``jurisdiction`` (ISO-3166-1 alpha-2) or rely on a stored attestation; unknown jurisdiction is DENIED. ``confirm=true`` additionally requires ``disclosures_acknowledged=true`` -- read the mandatory pre-pledge disclosure block (``get_ilo_details`` or a plan-mode preview) first (I2). Workflow: EXECUTE step -- get_ilo_details, then plan-mode preview, then confirm=true. Track it afterwards with get_my_pledge_status.

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

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.

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. detail="concise" (default) returns total_value_usd/change_24h_pct/snapshot_id + up to the top 10 positions (token/symbol/usd_value -- IDs for chaining); "full" returns every position with amount/price_usd and the complete allocation_pcts map, as before. Workflow: 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.

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, released 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.

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. 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/replace/clear the AGNTA counterparty allow-set for the caller's opted-in DelegationGrant (non-custodial control plane). Persists to Django so the set survives an MCP process restart and is visible to every process -- the follow-up to 's process-local ``InMemoryCounterpartySetResolver``. ``wallet_address`` must belong to an ``AgentWallet`` with a non-blank ``agnta_grant_pda`` already configured (opting in is a separate step, out of scope here); the target grant_pda is always resolved from that wallet, never caller-supplied. ``members`` is a list of base58 32-byte destination pubkeys the grant's ``counterparty_root`` should allow -- pass an EMPTY list to CLEAR the registered set, after which every transfer-class call naming an on-chain destination for this grant fails closed. ``expected_root`` (hex, optional but STRONGLY recommended): compare against the grant's live on-chain ``counterparty_root`` (hex-encoded) before calling this -- when given, a set that does not commit to it is refused (INVALID_PARAMS) rather than silently registered, which would otherwise surface later as a confusing AGNTA_GRANT_COUNTERPARTY_DENIED on an unrelated transfer.

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

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

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.

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

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

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

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.

Keyword search over the full Crank tool catalog (progressive disclosure). Read-only, free, never gated. Purpose-built for a discovering agent that does not want to load the full tool catalogue into context just to find the one it needs ( R1 -- the Solana Agent Kit V1 failure mode: 60+ tools in context caused tool-selection hallucinations). Pass a keyword or short phrase (e.g. "perp funding rate", "stake sol", "referral"); matches rank by keyword overlap against each tool's name + description. Returns up to ``limit`` (default 10, max 50) results, each ``{name, purpose, toolset}`` -- ``purpose`` is a one-line summary (call the tool itself, or get_trading_workflow, for the full picture), and ``toolset`` names which of the ten named toolsets (market_data, spot, perps, lending_staking, portfolio, strategies, intelligence, rewards_growth, wallet_admin, support) the tool belongs to. No tool is renamed or hidden by this search -- it is purely a discovery aid.

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

Opt a wallet into an AGNTA DelegationGrant spend/scope cap (non-custodial control plane). Validates grant_pda decodes as a base58 32-byte address, the on-chain account exists and decodes as a DelegationGrant, it is not revoked and not expired, and its delegate matches wallet_address -- every failure raises INVALID_PARAMS with a distinct message. Adds an ADDITIONAL cap enforced alongside (never replacing) WalletPolicy on every subsequent value-bearing call for this wallet -- always TIGHTENS enforcement, so it applies directly for every wallet, Lane 2 included.

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

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

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.

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). Setting an escalation_webhook mints a platform-generated escalation_webhook_secret used to HMAC-SHA256-sign every escalation POST (X-Crank-Signature over "{timestamp}.{body}"). The RAW secret is returned exactly once -- in this write's response -- so the receiver can be configured; every later read returns it masked. It is carried forward unchanged when the URL is unchanged, rotated automatically when the URL changes, and rotated on demand with rotate_escalation_secret=true. It is a receiver-authentication credential, never wallet key or seed material (hard rule 1). 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).

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

Pre-filled post for a journal card, ready to publish (free read). Returns the same card as get_journal_card plus a platform-shaped share payload: post text within the platform's character limit, the public card URL, and a compose-intent URL. ``platform`` is x | farcaster | generic. The copy is about YOUR process -- what your agent decided, that the rationale was written down before the outcome, and that the record is checkable on-chain. It never states or implies a return. THIS CALL PUBLISHES THE DECISION. Your journal is private by default; calling this marks THIS decision publicly readable at its card URL so the link in the post resolves for anyone (and for answer engines). Nothing else is published -- not your other decisions, not amounts, not your journal body unless include_rationale=true. Reviewing with get_journal_card publishes nothing. Workflow: SHARE step -- get_journal_card to review, this to publish.

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