Start here. With no trader_id, provisions your paper trader and returns the full integration guide (trade flow, 50 bps + $0.50 min fee, safety rules, copy-paste prompts). With a trader_id, returns the guide plus your trader status. Paper mode: simulated fills, play funds, real dry quotes and real token inspections — nothing here can move real money. Persist the trader_id in your own config/memory after first setup; pass it to every other tool.

Provision the human's trading wallet and get their claim link. Call this on your own as soon as you are connected — the human should never have to ask for it. One wallet per trader: if a wallet was already provisioned, the existing claim link is returned (never mint two). Present the claim_url to the human and tell them it is a 2-minute ceremony (fingerprint, 12-word backup, deposit address). Then poll claim_status until backed_up is true.

Check the human's claim-ceremony progress for this trader's wallet. Poll this after provision_wallet until backed_up is true. The deposit address is included ONLY after the human confirmed their 12-word backup — never invent or reveal an address earlier.

Credit your paper trader with PLAY funds (the sandbox faucet). Paper mode only — these funds are simulated and worthless. This is the "deposit is the signup" step for paper: fund the trader, then trade. In live mode this tool does not exist; funding is a real onchain deposit to your Turnkey wallet.

Inspect a token BEFORE any trade talk: paste the contract address (CA), get red flags + facts. Checks: honeypot (buy AND sell simulation), buy/sell tax, mintable supply, ownership/proxy status, holder count, price, liquidity, 24h volume, market cap. Verdicts: BLOCKED (honeypot — no quote, no fill, ever), REVIEW_REQUIRED (red flags — user must approve explicitly regardless of size), NO_RED_FLAGS_DETECTED. The agent NEVER says "looks safe" — report the checks and the numbers, then ask the user what they want to do. Call this first, every time, before swap_quote.

Dry quote for a swap: real venue quotes (KyberSwap/Jupiter/0x), best net-of-fee fill wins. The 402 fee — max(50 bps, $0.50 minimum, the min is a placeholder until the Turnkey bill calibrates it) — is applied AT THE QUOTE LAYER — the response shows amount_out_gross, fee, and amount_out_net separately, and amount_out_net is what a fill would deliver. BLOCKED (honeypot) tokens get no quote, ever — the token being bought is inspected before quoting. amount_in_usd is the server-side USD valuation the auto-approve threshold is enforced against. Quotes live 60 seconds and fill at most once; swap_execute rejects stale or consumed quotes. No signing, no broadcasting — quoting is always safe. For ETH use token 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE on EVM.

Execute a swap_quote (PAPER FILL in paper mode — simulated at the quoted net price, never real money). LIVE MODE: swap execution is not wired yet (Phase 3) — the signer is ready (see signer_status / signer_sign_transaction) but swap calldata construction comes next; swap_execute refuses in live mode. Approval, enforced server-side: pass user_approved=true when the user explicitly approved this trade, OR leave it false and let auto-approve decide — that path only fills when the trader set a threshold via set_auto_approve, the trade's server-side USD value is known and at/under it, and the execution-time inspection is fully green. Red flags always need an explicit yes regardless of size; honeypots never fill. Execution-time safety: the token being bought is re-inspected NOW (honeypot turned on between quote and fill = blocked). Each quote fills at most once; the fill is atomic (balances + trade + fee records move together). Fails if the kill switch is engaged or the quote expired. Returns a paper: reference — paper fills are never confused with real tx hashes.

Check a fill by trade_id: status, amounts, fee, venue, and reference. Paper fills carry a paper: reference, never a real transaction hash.

The chat-native portfolio view: every paper balance for the trader (symbol, amount, chain), recent fills, and total 402 fees accrued in the paper fee ledger. Use it to answer "what do I hold?" and "what have I paid in fees?".

Withdraw to an external wallet. ALWAYS requires explicit per-action approval: pass confirmed=true only after reading the amount AND destination back to the user and getting a yes — the server records the read-back values. Paper mode: records the withdrawal and debits the paper balance; status PAPER_RECORDED, no real movement. Live mode (Phase 2): Turnkey policy enforces withdrawals to the owner's pre-registered wallet only. Never auto-executes.

Arm a standing strategy in plain language: "sell half my FUG if it doubles" = sell_pct 50, price_up_pct 100. The live price right now becomes the baseline; the trigger fires ONCE when the price rises by price_up_pct, selling sell_pct of the token balance into the stable. Firing executes within the trigger's own caps under the user's standing approval from this call. Red-flagged (BLOCKED) tokens cannot be armed.

List all triggers for a trader: armed and fired, with baselines and fire times.

Disarm a trigger by trigger_id. Only the owning trader can cancel it.

Poll every armed trigger once against live prices and fire the tripped ones (paper fills within their caps). In production this runs on a cron; the tool exists so agents and tests can drive it directly. Returns one report per trigger checked.

KILL SWITCH. Stops everything immediately: fills, trigger arming, and trigger firing all fail while paused. No confirmation needed to stop — stopping is always safe. Call the moment anything looks wrong: "stop everything" / "pause trading".

Lift the kill switch after pause_trading. Trading, trigger arming, and firing resume.

Set the per-trade auto-approve threshold in USD for this trader (default 0 = always ask). Trades at or under the threshold with green safety auto-execute once the user's standing approval exists; anything over it — or any red flag regardless of size — needs an explicit yes per trade. No maximum: set it as high as the user wants. The server enforces the threshold itself; the agent cannot talk its way around it.