back
loading skill details...
AI-powered perpetual futures trading on Hyperliquid DEX. Handles full account creation, USDC onboarding, and autonomous trade execution.
---
name: shekel-hyperliquid
version: 1.14.0
description: >
AI-powered perpetual futures trading on Hyperliquid DEX.
Handles full account creation, USDC onboarding, and autonomous trade execution.
author: shekel
runtime: node>=20
metadata:
openclaw:
requires:
env:
- SHEKEL_API_KEY
primaryEnv: SHEKEL_API_KEY
homepage: https://shekel-skill-backend.onrender.com/skill
emoji: "📈"
---
# Shekel Hyperliquid Skill — Complete Documentation
## ⚠️ MANDATORY: Always Check for Latest Skill Version
**Before EVERY interaction with Shekel endpoints**, you MUST:
1. Call `GET /skill/version` to get the current skill hash
2. Compare it to your cached version
3. If different (or no cache), fetch `GET /skill` and use the updated instructions
```bash
# Quick version check (do this before any Shekel action)
curl https://shekel-skill-backend.onrender.com/skill/version
# Returns: { "version": "abc123...", "fetchUrl": "...", "instruction": "..." }
```
**Why?** Supported networks, deposit methods, and API behavior change. Using outdated instructions will cause errors or give users wrong information.
> **Health check** (no auth): `GET /health` — also returns `skillVersion` hash for comparison.
---
## Quick Reference
| Goal | Endpoint |
|---|---|
| **Browser UI (no code needed)** | `GET /dashboard` → `https://www.shekel.xyz/hl-skill-dashboard` |
| **Service health** | `GET /health` |
| New user onboarding | `POST /auth/register/managed` |
| Check deposit / activation | `GET /auth/deposit-status` |
| Retry stuck deposit | `POST /auth/retry-deposit` |
| **Run agent (all whitelist tickers)** | `POST /agent/run` |
| Run agent (single ticker) | `POST /agent/run` with `{ "ticker": "BTC" }` |
| Close all open positions | `POST /account/close-positions` |
| View config | `GET /agents` |
| View balances | `GET /account/balances` — includes `vaultEquityUsdc` + `totalEquityUsdc` |
| View positions | `GET /account/portfolio` |
| View open orders | `GET /account/orders` |
| View trade history | `GET /account/trades` |
| **View performance metrics** | `GET /agent/performance` |
| **View trading memory + improvement plan** | `GET /agent/memory` |
| View LLM reasoning logs | `GET /agent/llm-logs` (supports `?ticker=BTC&action=LONG&executed=true&limit=100&offset=0`) |
| View on Hyperliquid explorer | `GET /account/url` |
| Update strategy | `PATCH /agent/prompt` |
| Update whitelist / settings | `PUT /agents/:id` |
| Enable / change schedule | `PUT /agents/:id` with `runScheduleMinutes` |
| Disable schedule | `PUT /agents/:id` with `{ "runScheduleMinutes": null }` |
| Set risk limits | `PUT /agents/:id` with `maxOpenPositions`, `maxDailyLossPct`, `maxDrawdownPct` |
| Browse data sources | `GET /agents/data-sources` |
| Toggle data sources | `PUT /agents/:id` with `dataSourceConfig` |
| Set margin mode | `PUT /agents/:id` with `{ "marginMode": "isolated" \| "cross" }` |
| Pause / resume agent | `PATCH /agent/active` |
| Deposit address (top-up) | `GET /account/deposit-address` |
| Bridge funds (manual, usually not needed) | `POST /account/bridge` |
| Withdraw to Arbitrum | `POST /account/withdraw` |
| Rotate API key | `POST /auth/rotate-key` |
| Export trading wallet key | `POST /auth/export-agent-key` |
| Delete account | `DELETE /auth/account` |
| Available models | `GET /agents/models` — returns `{ venice: [...], rei: [...] }` |
| Available markets | `GET /markets/tickers` |
| **Create vault (agent as fund manager)** | `POST /vault/create` |
| View my vault | `GET /vault/my` |
| Vault page (public, no auth) | `GET /vault/page?vaultAddress=0x...` |
| Vault details by address | `GET /vault/details?vaultAddress=0x...` |
| My leading vaults | `GET /vault/leading` |
| My vault deposits (all vaults) | `GET /vault/deposits` |
| **Discover top vaults** | `GET /vault/explore?sortBy=tvl&order=desc` (no auth, sortBy: apr/tvl) |
| Recent vaults (last 2 hrs) | `GET /vault/summaries` (no auth) |
| Deposit into any vault | `POST /vault/deposit` with `{ "vaultAddress": "0x...", "amountUsdc": 10 }` |
| Deposit into own vault | `POST /vault/deposit` with `{ "amountUsdc": 10 }` |
| Withdraw from any vault | `POST /vault/withdraw` with `{ "vaultAddress": "0x...", "amountUsdc": 10 }` |
| Update vault settings | `PUT /vault/settings` |
| Distribute vault profits | `POST /vault/distribute` |
| Link agent to existing vault | `PUT /agents/:id` with `{ "vaultAddress": "0x..." }` |
---
## Dashboard (Browser UI)
Users who prefer a visual interface can manage their agent at **https://www.shekel.xyz/hl-skill-dashboard** — no code required.
### What the dashboard provides
- Account overview: balances, open positions, trade history
- Agent configuration: strategy, whitelist, risk limits, schedule
- LLM reasoning logs: see what the agent was thinking on each run
- One-click actions: run agent, close positions, pause/resume
### How to connect
1. Direct the user to `https://www.shekel.xyz/hl-skill-dashboard`
2. They enter their `apiKey` (`sk_...`) on the login screen
3. The dashboard authenticates using the same `Authorization: Bearer <apiKey>` header as the REST API — no separate credentials needed
### If the user has no account yet
Offer two paths:
- **Via dashboard**: Visit the URL above and use the "Create Account" flow
- **Via AI**: Run through the onboarding steps below (Steps 1–5) and hand them their `apiKey` when done
> Call `GET /dashboard` to get the latest URL and access instructions programmatically.
---
## Returning Users
> This is the common case — check here first.
**Check your memory first.** If you saved credentials during onboarding (see Step 2a), load them from `MEMORY.md` — do not ask the user for their API key if you already have it. Only ask if memory is empty or the key returns a `401`.
If you must ask the user, only ask for their `apiKey` — that is the only credential needed for everything.
```
GET /agents → returns agentName, config, strategy
GET /account/balances → show current funds
GET /auth/deposit-status → confirm account is active
```
Then based on what you find:
- `status !== "active"` → follow Steps 3–5 of onboarding below
- `isActive === false` on agent → ask if they want to resume: `PATCH /agent/active { "active": true }`
- Want to change strategy → `PATCH /agent/prompt`
- Want to top up → `GET /account/deposit-address` (send USDC, it auto-bridges in ~30-60s)
- Want to see trades → `GET /account/url` for Hyperliquid explorer link
---
## Onboarding (New User)
### Quick Start (recommended)
**Offer this first** — most users just want to get going. Don't overwhelm with 15 questions.
> "I can set up your trading agent with sensible defaults. Just answer 4 questions:
> 1. **Which coins?** (default: BTC, ETH, SOL)
> 2. **Risk level?** conservative / moderate / aggressive
> 3. **How much USDC are you depositing?** (minimum 5 USDC)
> 4. **How often should the agent trade?** (default: every 4 hours)
>
> That's it — I'll use a momentum strategy with appropriate position sizes. You can customize everything later."
**Quick start defaults by risk level:**
| Risk | `positionSizeMax` | `maxTradeSize` | `importantNotes` |
|---|---|---|---|
| Conservative | 10% | 10% of deposit | "Max 3x leverage. Always use stop losses within 3% of entry. Avoid trading during high volatility news events. Never risk more than 5% of account on any single trade." |
| Moderate | 20% | 20% of deposit | "Max 5x leverage. Use stop losses on every trade. Exit losing positions quickly. Scale into winners gradually." |
| Aggressive | 35% | 40% of deposit | "Max 10x leverage allowed. Use tight stop losses. Accept higher drawdowns for higher returns. Trade momentum aggressively." |
**Quick start registration payload example (moderate risk, $500 deposit):**
```json
{
"agentName": "My Trading Agent",
"model": "grok-41-fast",
"tradingStyle": "momentum",
"strategyDescription": "Enter longs on price breakouts above recent highs with above-average volume. Enter shorts on breakdowns below recent lows. Exit when momentum reverses or RSI indicates overbought/oversold. Avoid ranging, low-volume markets. Use stop losses on every trade.",
"importantNotes": "Max 5x leverage. Use stop losses on every trade. Exit losing positions quickly. Scale into winners gradually.",
"minTradeSize": 10,
"maxTradeSize": 100,
"positionSizeMin": 5,
"positionSizeMax": 20,
"usdcRangeMin": 300,
"usdcRangeMax": 1000,
"whitelist": ["BTC", "ETH", "SOL"]
}
```
**After registration:** Set up the run schedule with `PUT /agents/:id` using `{ "runScheduleMinutes": 240 }` (4 hours).
If the user wants to fully customize, use the full flow below.
---
### LLM Provider Selection
Agents can use one of two LLM providers. The default is **Venice AI** (no user API key needed — platform-provided).
| Provider | `provider` value | `model` options | Key required? |
|---|---|---|---|
| Venice AI | `"venice"` | `grok-41-fast`, `qwen3-235b`, others | No (platform key) |
| Rei Intelligence | `"rei"` | `rei-coder-pro` (shown as **GPT-5.4**), `rei-coder-lite`, `rei-qwen3-coder` | Yes — user supplies `llmApiKey` |
To use Rei, include `provider` and `llmApiKey` in registration or agent update:
```json
{
"provider": "rei",
"model": "rei-coder-pro",
"llmApiKey": "user_rei_api_key_here",
...
}
```
The Rei API key is encrypted at rest. Use `GET /agents/models` to see all available models per provider.
---
### Full Onboarding (5 steps)
**Checklist — do not skip steps:**
1. Discover markets → validate whitelist
2. Register → **save API key to memory + confirm user has it (do not continue until done)**
3. Deposit USDC
4. Poll until `status === "active"`
5. Set run schedule → start trading
---
#### Step 1 — Discover Markets
```
GET /markets/tickers (no auth required)
```
Show the user the available coins. Validate any tickers they name against this list before registration — the server also validates, but catching it early saves a round trip.
The response has two sections:
- `tickers` — main-dex crypto perps (BTC, ETH, SOL, …)
- `hip3` — HIP-3 builder-dex perps: stocks, commodities, indices (TSLA, NVDA, CL/oil, …)
HIP-3 tickers use the format `"dex:ASSET"` (e.g. `"xyz:TSLA"`, `"xyz:CL"`). Use this full prefixed form in the whitelist — **not** the bare asset name.
---
#### Step 2 — Register
```
POST /auth/register/managed
```
```json
{
"agentName": "My Trading Bot",
"model": "grok-41-fast",
"tradingStyle": "momentum",
"strategyDescription": "...",
"importantNotes": "...",
"minTradeSize": 10,
"maxTradeSize": 100,
"positionSizeMin": 5,
"positionSizeMax": 20,
"usdcRangeMin": 200,
"usdcRangeMax": 1000,
"whitelist": ["BTC", "ETH", "SOL"],
"marginMode": "isolated"
}
```
To trade HIP-3 assets (stocks, commodities), use the prefixed format:
```json
{
"whitelist": ["BTC", "xyz:TSLA", "xyz:NVDA", "xyz:CL"]
}
```
**Before submitting:** show the user a summary and ask them to confirm.
**Response:**
```json
{
"apiKey": "sk_...",
"mainWalletAddress": "0x...",
"depositInstructions": { "depositAddress": "0x...", "network": "Arbitrum" }
}
```
> ### ⛔ STOP — SAVE THE API KEY NOW
>
> **The `apiKey` is shown once and can never be retrieved. If lost without rotating, access to the account and funds may be permanently lost.**
>
> Follow the steps below — do not continue until all three are done.
---
#### Step 2a — Secure Key Storage (do not skip)
Do all three of the following before continuing:
**1. Tell the user to save it themselves**
Say this out loud to the user:
> *"Your API key is `sk_...`. This is shown only once — copy it now into a password manager (1Password, Bitwarden, Apple Keychain) or a secure encrypted note. Do not store it in plain text, a Google Doc, or a chat message. Confirm when done."*
Wait for confirmation before proceeding.
**2. Save to your own OpenClaw Memory**
Write the following block to your `MEMORY.md` (or a dedicated `shekel-credentials.md` if your platform supports it):
```markdown
## Shekel Hyperliquid — Credentials
- apiKey: sk_... ← encrypted at rest by OpenClaw
- agentName: <name>
- registeredAt: <ISO timestamp>
- depositAddress: <0x...> (Arbitrum/Base)
```
> This allows you to recall the API key in future sessions without asking the user again. OpenClaw memory is encrypted at rest — it is safe to store the key here.
**3. Verify you can recall it**
After writing to memory, immediately read it back and confirm the key matches what the server returned. This proves the memory write succeeded before you move on.
> If lost later: `POST /auth/rotate-key` — generates a new key. You must be authenticated (have a working session) to rotate. If the key is truly lost and no session exists, the account cannot be recovered without re-registering.
---
#### Step 3 — Deposit USDC
Send to `depositAddress`. Both networks are fully automated:
| Network | Token | Time |
|---|---|---|
| **Arbitrum** *(recommended)* | USDC | ~60–90 seconds |
| Base | USDC | **~30 seconds** (Across Protocol bridge) |
> **Base deposits are fast now!** Across Protocol bridges in ~2 seconds, then funds are bridged to Hyperliquid. Total time: ~30 seconds.
Minimum: **5 USDC**
---
#### Step 4 — Wait for Activation
```
GET /auth/deposit-status (auth required)
```
Poll every 15 seconds. Use `message` to keep the user informed.
```json
{ "status": "active", "depositConfirmed": true, "message": "Account is active and ready to trade." }
```
Status values:
- `awaiting_deposit` — no USDC detected yet
- `funded_awaiting_bridge` — USDC found on Arbitrum, bridging to Hyperliquid (~60-90s)
- `pending_bridge` — USDC being bridged from Base via Across Protocol (~30 seconds). No action needed.
- `bridge_error` — bridge failed; call `POST /auth/retry-deposit` immediately
- `active` — ready to trade
**Timeout:** if still `awaiting_deposit` after 5 minutes, ask the user to confirm they sent to the correct address on Arbitrum or Base (not Ethereum mainnet).
**On `bridge_error`:** call `POST /auth/retry-deposit` — do not wait, the error won't self-resolve.
---
#### Step 5 — Set Up Automated Trading
> **Do not skip this step.** Without a schedule the account sits funded but idle.
Ask the user:
> "Your account is active! How often should the agent analyze and trade?
> - Every 30 minutes (high-frequency)
> - Every 1 hour (active)
> - **Every 4 hours** (recommended default)
> - Every 8 hours (conservative)
> - Once a day (240 or 1440 minutes)
> Or tell me any interval (minimum 30 minutes)."
Once they choose, **enable the built-in schedule** via `PUT /agents/:id`:
```bash
curl -X PUT https://shekel-skill-backend.onrender.com/agents/<agentId> \
-H "Authorization: Bearer <apiKey>" \
-H "Content-Type: application/json" \
-d '{"runScheduleMinutes": 240}'
```
The server will run the agent automatically every N minutes — no external cron needed.
The first run fires in N minutes. The `GET /agents` response includes `nextRunAt` so you can show the user when to expect the first execution.
Then **run it once immediately** so the user sees it working:
```
POST /agent/run
```
**Scheduling notes:**
- Minimum interval: 30 minutes
- To change interval: `PUT /agents/:id { "runScheduleMinutes": 60 }` — resets `nextRunAt` to `now() + new interval`; saving other settings without changing the interval preserves the existing timer
- To disable: `PUT /agents/:id { "runScheduleMinutes": null }`
- To pause without clearing schedule: `PATCH /agent/active { "active": false }` — schedule resumes when reactivated
- `429` means a manual run collided with a scheduled run — wait a few minutes
---
## Risk Circuit Breakers
Optional safety limits that automatically block or pause trading when thresholds are breached. Set via `PUT /agents/:id`.
```bash
curl -X PUT https://shekel-skill-backend.onrender.com/agents/<agentId> \
-H "Authorization: Bearer <apiKey>" \
-H "Content-Type: application/json" \
-d '{
"maxOpenPositions": 3,
"maxDailyLossPct": 5,
"maxDrawdownPct": 20
}'
```
| Field | Behavior |
|---|---|
| `maxOpenPositions` | Blocks new LONG/SHORT entries when open position count ≥ limit. CLOSE still allowed. |
| `maxDailyLossPct` | Blocks new LONG/SHORT entries for the rest of the UTC calendar day when realised PnL drops below -(N% of account value). Resets at UTC midnight. |
| `maxDrawdownPct` | **Auto-pauses the agent** (`isActive=false`) when account value has fallen ≥ N% from its peak. Requires `PATCH /agent/active { "active": true }` to re-enable after the user reviews. |
Set any to `null` to disable. Circuit breaker trips appear in `GET /agent/llm-logs` as `executionError` on the blocked recommendation — the LLM's reasoning is still logged even when a trade is blocked.
---
## Data Source Configuration
Use `dataSourceConfig` in `PUT /agents/:id` to turn individual data sources on or off. Every key is `true` by default — you only need to set the ones you want to change. Unknown keys are rejected with a `400` error.
**Valid keys (set to `false` to disable, `true` or omit to enable):**
| Key | Display Name | Provider | What it gives the LLM |
|---|---|---|---|
| `tokenData` | Token Data | DappLooker | Per-ticker perp market data — funding rate, open interest, volume, price action |
| `sentiment` | Macro News | — | Real-time crypto macro news and sentiment |
| `fearGreed` | Fear & Greed Index | CoinMarketCap | Fear & Greed index (0–100) |
| `globalMetrics` | Global Market Metrics | CoinMarketCap | Total market cap, BTC dominance, 24h volume |
| `technicalAnalysis` | Technical Analysis | DappLooker/Taapi | RSI, MACD, moving averages per ticker |
| `athenaTokenStats` | Smart Money Movements | 0xAthena | On-chain smart money token flow data per coin |
| `athenaLatest` | 0xAthena Signals | 0xAthena | Latest aggregated smart money signals |
**Example — disable Athena and sentiment:**
```bash
curl -X PUT https://shekel-skill-backend.onrender.com/agents/<agentId> \
-H "Authorization: Bearer <apiKey>" \
-H "Content-Type: application/json" \
-d '{
"dataSourceConfig": {
"athenaTokenStats": false,
"athenaLatest": false,
"sentiment": false
}
}'
```
Set `dataSourceConfig: null` to re-enable everything. Current config is returned by `GET /agents`.
---
## Margin Mode
Each agent has a `marginMode` setting (`"isolated"` or `"cross"`). Default is `"isolated"`.
| Mode | Behaviour |
|---|---|
| `isolated` | Each position has its own margin. Safer — one liquidation can't cascade. **Required** for assets where `onlyIsolated: true` in `/markets/tickers`. |
| `cross` | All positions share account margin. More capital-efficient, higher liquidation risk. |
Set or change at any time via `PUT /agents/:id`:
```bash
curl -X PUT .../agents/<agentId> \
-H "Authorization: Bearer <apiKey>" \
-H "Content-Type: application/json" \
-d '{ "marginMode": "isolated" }'
```
**Smart override:** If a Hyperliquid asset is `onlyIsolated: true`, the agent runner forces isolated margin for that trade even when the agent is set to `"cross"`. Check `/markets/tickers` for `onlyIsolated` and `marginMode` fields per ticker.
---
## Running the Agent
`POST /agent/run` analyzes coins and executes recommendations automatically. It has two modes:
**Full whitelist run** (no body required — runs all whitelisted tickers):
```bash
curl -X POST https://shekel-skill-backend.onrender.com/agent/run \
-H "Authorization: Bearer <apiKey>"
```
**Single-ticker run** (specify a ticker — runs even if not in the whitelist):
```bash
curl -X POST https://shekel-skill-backend.onrender.com/agent/run \
-H "Authorization: Bearer <apiKey>" \
-H "Content-Type: application/json" \
-d '{ "ticker": "BTC" }'
```
**Optional body fields for single-ticker runs** (all auto-fetched if omitted):
| Field | Type | Description |
|---|---|---|
| `ticker` | string | Run on this ticker only, bypassing the whitelist |
| `tokenData` | any | Override server-fetched token data |
| `sentiment` | any | Override server-fetched sentiment |
| `marketData` | any | Additional market context |
| `customData` | any | Any extra data to inject into the LLM prompt |
| `skillGuidance` | any | External signals for the LLM |
| `tradingMemoryContext` | any | Override the agent's trading memory |
Both modes return the same `{ results: [] }` shape and are subject to the 5-minute run lock.
### Data Sources Used in `/agent/run`
Each run automatically fetches and injects the following live data into the LLM prompt:
| Source | Data |
|---|---|
| **Hyperliquid** | Live portfolio (positions, balances, open orders) — includes HIP-3 builder-dex positions and orders (e.g. `xyz:TSLA`) merged transparently alongside main-dex crypto perp positions; open orders include limit, stop-loss, and take-profit orders |
| **DappLooker** | Token price, volume, and market data for each whitelisted coin |
| **0xAthena** | Smart money token stats (hold times, flows) + latest aggregated signals |
| **DappLooker** | On-chain DEX analytics and market metrics |
No extra parameters are needed — all data is fetched server-side on every run.
---
## Error Handling
| Status | Meaning | Action |
|---|---|---|
| `400` | Bad request | Fix and retry |
| `401` | Invalid API key | Check key; rotate if needed |
| `404` | Resource not found | Check IDs |
| `422` | Hyperliquid rejected order | `message` field has reason |
| `429` | Rate limit or run in progress | **Wait 5 minutes** before retrying `/agent/run`; wait 60 seconds for other endpoints |
| `502` | Hyperliquid API down | Retry after 10–30 seconds |
| `503` | Service degraded | Retry after 30 seconds |
---
## Troubleshooting
**Agent isn't trading:**
- `GET /agents` → check `isActive` (may be paused)
- `GET /auth/deposit-status` → must be `active`
- `GET /account/balances` → check margin isn't below `usdcRangeMin`
**Deposit not arriving:**
- Arbitrum: wait 90s. Base: wait 60s. Not Ethereum mainnet.
- Minimum 5 USDC. Below this won't bridge.
- `bridge_error` → call `POST /auth/retry-deposit`
**429 on `/agent/run`:**
- A run is still in progress. The response includes `"unlocksAt"` — wait until that timestamp. The lock auto-expires after 5 minutes regardless.
**Whitelist update fails with "Invalid tickers":**
- Check `GET /markets/tickers` — names must match exactly
- Main-dex coins are uppercase: `"BTC"`, `"ETH"`
- HIP-3 coins use `"dex:ASSET"` format: `"xyz:TSLA"`, `"xyz:CL"` (lowercase dex prefix, uppercase asset)
---
## ⚠️ Inactivity Archival Policy
**Agents with no trades for 14+ days are automatically archived.**
- The archival check runs daily
- Archived agents cannot execute trades or access the API
- Agent data (trade history, LLM logs) is preserved
- **Funds are safe** — the encrypted wallet key is stored for recovery
**Exceptions (not archived):**
- Agents with balance > $100 USDC
- Agents with open positions
**If your agent is archived:**
- You'll receive a `410 Gone` error when hitting any authenticated endpoint
- Contact support via Telegram to restore: [https://t.me/c/2308722458/1](https://t.me/c/2308722458/1)
- Provide your wallet address or agent name for recovery
---
## Vault Management (Agent as Fund Manager)
Shekel agents can create and manage a **Hyperliquid vault** — turning the AI agent into a publicly investable on-chain fund. Followers deposit USDC into the vault and share P&L proportionally, while the agent (as vault leader) earns **10% of profits**.
### Key Concepts
| Concept | Details |
|---|---|
| **Model** | Agent trades, followers deposit and share P&L proportionally |
| **Leader profit share** | 10% of profits (fixed, cannot be changed) |
| **Creation cost** | 100 USDC fee + 100 USDC minimum initial deposit |
| **Leader equity** | Must maintain ≥5% of vault equity at all times |
| **Lockup** | 24 hours after each deposit (resets on new deposits) |
| **Key type requirement** | Write operations require a managed account or self_custody private_key account |
### Vault Mode Trading
Once a vault is created, you can link the agent to it so it **trades on behalf of the vault**:
```bash
# Option A: Create a vault (automatic linkage)
curl -X POST .../vault/create \
-H "Authorization: Bearer <apiKey>" \
-d '{"name":"My AI Fund","description":"BTC/ETH momentum strategy","initialUsd":200}'
# Returns the vault address and automatically links the agent
# Option B: Link agent to an existing vault
curl -X PUT .../agents/<id> \
-H "Authorization: Bearer <apiKey>" \
-d '{"vaultAddress":"0x..."}'
# Unlink agent from vault (reverts to personal wallet trading)
curl -X PUT .../agents/<id> \
-H "Authorization: Bearer <apiKey>" \
-d '{"vaultAddress":null}'
```
When vault mode is active (`agents.vaultAddress` is set):
- Portfolio is fetched from the vault's address (not the leader's personal wallet)
- All trades execute on behalf of the vault
- The agent runner enforces the ≥5% leader equity rule before trading
- Trade history records the `vaultAddress` for auditability
### Vault Write Operations
```bash
# Deposit more USDC into the vault (leader adding to own position)
POST /vault/deposit { "amountUsdc": 500 }
# Withdraw USDC from the vault (subject to 24h lockup)
POST /vault/withdraw { "amountUsdc": 100 }
# Control follower deposits and withdrawal behavior
PUT /vault/settings { "allowDeposits": true, "alwaysCloseOnWithdraw": false }
# Distribute profits to followers (0 = close vault)
POST /vault/distribute { "amountUsdc": 1000 }
```
> **Note:** Closing a vault (`amountUsdc: 0` in `/vault/distribute`) requires all positions to be closed first. The stored `vaultAddress` is cleared automatically on close.
### Vault Explorer
Discover top-performing vaults without needing to know addresses in advance:
```bash
# Top vaults by TVL (default)
GET /vault/explore
# Top vaults by APR, deposits-open only
GET /vault/explore?sortBy=apr&order=desc&allowDepositsOnly=true
# Minimum $10k TVL, paginated
GET /vault/explore?minTvl=10000&limit=10&offset=0
```
Query params: `sortBy` (apr|tvl, default tvl), `order` (asc|desc, default desc), `minTvl` (USDC, default 0), `limit` (max 100, default 20), `offset` (default 0).
The explorer includes well-known vaults (e.g. HLP) plus any vaults discovered recently from Hyperliquid's live feed. Results are cached for 2 minutes. Use the returned `vaultAddress` to call `GET /vault/page?vaultAddress=0x...` for the full vault detail page (no auth required) or `POST /vault/deposit` to invest.
---
## Support
If you encounter an issue that can't be resolved through the troubleshooting steps above, contact the Shekel team directly:
**Telegram support channel:** [https://t.me/c/2308722458/1](https://t.me/c/2308722458/1)
Include your `agentId` (from `GET /agents`) and a brief description of the issue when reaching out.
don't have the plugin yet? install it then click "run inline in claude" again.