@moonpay/cli 1.43.0 → 1.44.0

package/skills/moonpay-trading-automation/SKILL.md

@@ -40,7 +40,7 @@ AMOUNT=5
 
 # --- Execute ---
 log "SWAP: $AMOUNT $FROM_TOKEN -> $TO_TOKEN on $CHAIN"
-RESULT=$("$MP" -f compact token swap \
+RESULT=$("$MP" --json token swap \
   --wallet "$WALLET" --chain "$CHAIN" \
   --from-token "$FROM_TOKEN" --from-amount "$AMOUNT" \
   --to-token "$TO_TOKEN" 2>&1) || {
@@ -51,11 +51,23 @@ log "OK: $RESULT"
 ```
 
 Key points:
-- `mp -f compact` outputs single-line JSON, ideal for `jq` parsing
+- `mp --json` outputs single-line JSON, ideal for `jq` parsing
 - Use `$(which mp)` and store as `MP` — cron/launchd have minimal PATH
 - Wallet names only in scripts — `mp` handles keychain decryption at runtime
 - If the user gives token names/symbols, resolve to addresses first with `mp token search`
 
+## Pre-built strategy skills
+
+For three common strategies, prefer the dedicated skills over rolling your own:
+
+- **moonpay-trailing-stop** — Sell automatically if price drops X% from its peak.
+- **moonpay-take-profit-ladder** — Sell in chunks at preset price targets, hold the runner.
+- **moonpay-buy-the-dip** — Buy a fixed USD amount when 24h drawdown exceeds a threshold, with a cooldown.
+
+Each one comes with a verified shell-script template, the right cron cadence, and notes on common pitfalls. The patterns below (DCA, generic limit order, generic stop loss) are still the right starting point for strategies that don't fit those three.
+
+If the user is on the **MoonPay Agents desktop app**, recommend using its in-app automation panel instead of generating a shell script — the app provides a persistent chat session that holds strategy state across fires (high-water-mark, fired rungs, last-fire timestamp) without a separate `state.json` file. The shell-script + cron pattern below is the right choice for headless / server / CI contexts where the app isn't running.
+
 ## DCA (Dollar-Cost Averaging)
 
 "Buy $5 of SOL every day at 9am"
@@ -137,7 +149,7 @@ TARGET_PRICE=80
 SCRIPT_NAME="limit-buy-sol"
 
 # --- Check price ---
-PRICE=$("$MP" -f compact token retrieve --token "$TOKEN" --chain "$CHAIN" | jq -r '.marketData.price')
+PRICE=$("$MP" --json token retrieve --token "$TOKEN" --chain "$CHAIN" | jq -r '.marketData.price')
 
 if [ -z "$PRICE" ] || [ "$PRICE" = "null" ]; then
   log "LIMIT $SCRIPT_NAME: price fetch failed, skipping"
@@ -147,7 +159,7 @@ fi
 # --- Compare ---
 if (( $(echo "$PRICE < $TARGET_PRICE" | bc -l) )); then
   log "LIMIT $SCRIPT_NAME: price $PRICE < $TARGET_PRICE — executing buy"
-  RESULT=$("$MP" -f compact token swap \
+  RESULT=$("$MP" --json token swap \
     --wallet "$WALLET" --chain "$CHAIN" \
     --from-token "$BUY_WITH" --from-amount "$BUY_AMOUNT" \
     --to-token "$TOKEN" 2>&1) || {
@@ -186,16 +198,16 @@ TRIGGER_PRICE=70
 SCRIPT_NAME="stop-loss-sol"
 
 # --- Check price ---
-PRICE=$("$MP" -f compact token retrieve --token "$SELL_TOKEN" --chain "$CHAIN" | jq -r '.marketData.price')
+PRICE=$("$MP" --json token retrieve --token "$SELL_TOKEN" --chain "$CHAIN" | jq -r '.marketData.price')
 
 if (( $(echo "$PRICE < $TRIGGER_PRICE" | bc -l) )); then
   # Get current balance to sell all
-  BALANCE=$("$MP" -f compact token balance list --wallet "$WALLET" --chain "$CHAIN" \
+  BALANCE=$("$MP" --json token balance list --wallet "$WALLET" --chain "$CHAIN" \
     | jq -r --arg addr "$SELL_TOKEN" '.items[] | select(.address == $addr) | .balance.amount')
 
   if [ -n "$BALANCE" ] && (( $(echo "$BALANCE > 0" | bc -l) )); then
     log "STOP-LOSS $SCRIPT_NAME: price $PRICE < $TRIGGER_PRICE — selling $BALANCE"
-    RESULT=$("$MP" -f compact token swap \
+    RESULT=$("$MP" --json token swap \
       --wallet "$WALLET" --chain "$CHAIN" \
       --from-token "$SELL_TOKEN" --from-amount "$BALANCE" \
       --to-token "$TO_TOKEN" 2>&1) || {
@@ -270,6 +282,9 @@ fi
 
 ## Related skills
 
+- **moonpay-trailing-stop** — Mechanical trailing stop with shipped reference script
+- **moonpay-take-profit-ladder** — Laddered partial sells at preset price targets
+- **moonpay-buy-the-dip** — Conditional buy on drawdown with cooldown
 - **moonpay-swap-tokens** — Swap and bridge command syntax
 - **moonpay-check-wallet** — Check balances before setting up automation
 - **moonpay-discover-tokens** — Research tokens and resolve addresses

package/skills/moonpay-trailing-stop/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: moonpay-trailing-stop
+description: Run a trailing stop on one position — sell automatically if the price drops a fixed % from its peak since you started watching. Mechanical execution, no overrides.
+tags: [trading, automation, stop-loss]
+---
+
+# Trailing stop
+
+## Goal
+
+Watch a single position and automatically sell it into a stable (USDC by default) if its price falls a fixed percent from the high-water-mark recorded since the strategy started. The whole point is mechanical execution — never widen the stop because "it'll come back."
+
+This skill works in two contexts:
+- **Inside an automation harness** (the MoonPay Agents desktop app): chat session memory holds the high-water-mark across fires.
+- **Headless via cron / launchd**: a JSON file at `~/.config/moonpay/state/trailing-stop-<id>.json` holds the same state.
+
+The decision logic is identical; only the persistence layer differs.
+
+## Prerequisites
+
+- `mp` authenticated: `mp user retrieve`
+- The target position is held in a wallet `mp wallet list` knows about
+- `jq` installed: `which jq`
+
+## Configuration
+
+Required inputs to capture on first run (ask the user, then persist):
+
+| Field | Notes |
+|---|---|
+| `token` | Token address. Resolve from a ticker with `mp token search --query <ticker> --chain <chain>` |
+| `chain` | e.g. `solana`, `ethereum`, `base` |
+| `wallet` | Wallet name (the local label, not the address) |
+| `trailing_pct` | Percent drop from peak that triggers the sell. Default: 12 |
+| `sell_into` | Token address to sell into. Default: USDC on the same chain |
+| `entry_price` | Optional — original cost basis if known. Used only for PnL reporting at exit |
+| `hwm` | Initial high-water-mark = current price at first fire |
+| `closed` | Boolean. False until the stop fires. After it fires, the strategy stops watching |
+
+## Per-fire workflow
+
+```
+1. If `closed`: log "position already closed" and exit.
+2. price = mp --json token retrieve --token $TOKEN --chain $CHAIN | jq '.marketData.price'
+3. balance = mp --json token balance list --wallet $WALLET_ADDR --chain $CHAIN
+            | jq --arg t $TOKEN '.items[] | select(.address==$t) | .balance.amount'
+4. If balance is null or 0: mark closed=true, log "no position, stopping", exit.
+5. If price > hwm: hwm = price. Log "new HWM $price (drawdown 0.00%)". Exit.
+6. drawdown_pct = (hwm - price) / hwm * 100
+7. If drawdown_pct >= trailing_pct: EXECUTE THE SELL (full balance). Log fill.
+   Mark closed=true. Optional: report PnL vs entry_price if known.
+8. Else: log "holding — price $price, HWM $hwm, drawdown $drawdown_pct%, gap to trigger $(trailing_pct - drawdown_pct)%". Exit.
+```
+
+The sell command:
+
+```bash
+mp --json token swap \
+  --wallet "$WALLET" \
+  --chain "$CHAIN" \
+  --from-token "$TOKEN" \
+  --from-amount "$BALANCE" \
+  --to-token "$SELL_INTO"
+```
+
+## Schedule
+
+A 15-minute interval is the right balance for most positions:
+- Cron: `*/15 * * * * /path/to/script.sh # moonpay:trailing-stop-<id>`
+- Launchd: `<key>StartInterval</key><integer>900</integer>`
+
+For volatile small-caps, drop to `*/5`. For large caps you're not actively trading, hourly is enough.
+
+## Headless reference script
+
+```bash
+#!/bin/bash
+set -euo pipefail
+MP="$(which mp)"
+ID="trailing-stop-sol-main"   # unique per strategy
+STATE="$HOME/.config/moonpay/state/${ID}.json"
+LOG="$HOME/.config/moonpay/logs/trading.log"
+mkdir -p "$(dirname "$STATE")" "$(dirname "$LOG")"
+log() { echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] $ID $*" >> "$LOG"; }
+
+# --- Config (fill these in once) ---
+TOKEN="So11111111111111111111111111111111111111112"   # SOL (WSOL mint)
+CHAIN="solana"
+WALLET="main"
+WALLET_ADDR="<address from mp wallet list>"
+TRAILING_PCT=12
+SELL_INTO="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"  # USDC
+
+# --- Load state (initialize on first run) ---
+if [ ! -f "$STATE" ]; then
+  PRICE=$("$MP" --json token retrieve --token "$TOKEN" --chain "$CHAIN" | jq '.marketData.price')
+  echo "{\"hwm\": $PRICE, \"closed\": false}" > "$STATE"
+  log "initialized hwm=$PRICE"
+fi
+CLOSED=$(jq -r '.closed' "$STATE")
+HWM=$(jq -r '.hwm' "$STATE")
+[ "$CLOSED" = "true" ] && { log "already closed, exit"; exit 0; }
+
+# --- Check price + balance ---
+PRICE=$("$MP" --json token retrieve --token "$TOKEN" --chain "$CHAIN" | jq '.marketData.price')
+BALANCE=$("$MP" --json token balance list --wallet "$WALLET_ADDR" --chain "$CHAIN" \
+  | jq --arg t "$TOKEN" '[.items[] | select(.address==$t) | .balance.amount][0] // 0')
+
+if (( $(echo "$BALANCE <= 0" | bc -l) )); then
+  jq '.closed = true' "$STATE" > "$STATE.tmp" && mv "$STATE.tmp" "$STATE"
+  log "no position, marked closed"; exit 0
+fi
+
+# --- Decide ---
+if (( $(echo "$PRICE > $HWM" | bc -l) )); then
+  jq --argjson p "$PRICE" '.hwm = $p' "$STATE" > "$STATE.tmp" && mv "$STATE.tmp" "$STATE"
+  log "new HWM $PRICE"
+  exit 0
+fi
+
+DRAWDOWN_PCT=$(echo "scale=4; ($HWM - $PRICE) / $HWM * 100" | bc -l)
+TRIGGER=$(echo "$DRAWDOWN_PCT >= $TRAILING_PCT" | bc -l)
+if [ "$TRIGGER" = "1" ]; then
+  log "TRIGGER: drawdown ${DRAWDOWN_PCT}% >= ${TRAILING_PCT}% — selling $BALANCE"
+  RESULT=$("$MP" --json token swap \
+    --wallet "$WALLET" --chain "$CHAIN" \
+    --from-token "$TOKEN" --from-amount "$BALANCE" \
+    --to-token "$SELL_INTO" 2>&1) || { log "SELL FAILED: $RESULT"; exit 1; }
+  log "SELL OK: $RESULT"
+  jq '.closed = true' "$STATE" > "$STATE.tmp" && mv "$STATE.tmp" "$STATE"
+else
+  log "holding — price $PRICE hwm $HWM drawdown ${DRAWDOWN_PCT}%"
+fi
+```
+
+## Inside an automation harness
+
+When this skill runs inside the MoonPay Agents desktop app, the harness provides a single resumed chat session — no state file needed. The agent persists `hwm` and `closed` in conversation memory and follows the same decision logic. The body of the in-app automation is a thin pointer to this skill.
+
+## Common pitfalls
+
+- **Hard-coding the SOL mint as `...111`**. The wrapped SOL mint ends in `112`. Resolve via `mp token search --query SOL --chain solana` if unsure.
+- **Skipping the balance check**. If the user manually sells the position between fires, the sell command will fail with insufficient balance. Always check balance first; mark closed and exit if zero.
+- **Widening the stop after a loss**. The strategy is defined by mechanical execution. If you find yourself wanting to override, the strategy isn't for this position.
+- **Not naming the cron entry**. Always tag scheduled entries with `# moonpay:trailing-stop-<id>` so they can be listed and removed cleanly.
+
+## Related skills
+
+- **moonpay-trading-automation** — Shell-script + cron/launchd patterns for headless automation
+- **moonpay-take-profit-ladder** — Companion strategy for partial-sell-on-the-way-up
+- **moonpay-discover-tokens** — Resolve tickers to token addresses
+- **moonpay-swap-tokens** — Underlying swap command syntax
+- **moonpay-check-wallet** — Position size lookup