@moonpay/cli 1.43.0 → 1.44.1

package/skills/moonpay-take-profit-ladder/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: moonpay-take-profit-ladder
+description: Sell a position in chunks at preset price targets, hold the runner. Each rung sells a slice of the CURRENT remaining position when its target price is crossed.
+tags: [trading, automation, take-profit]
+---
+
+# Take-profit ladder
+
+## Goal
+
+Lock in profit on a position progressively as price rises. The user defines rungs as `(price_multiplier, % of current position to sell)` pairs. As each rung is crossed, the strategy sells that slice and lets the rest ride.
+
+This skill works in two contexts:
+- **Inside an automation harness** (MoonPay Agents desktop app): chat session memory tracks fired/unfired rungs.
+- **Headless via cron / launchd**: a JSON file at `~/.config/moonpay/state/take-profit-ladder-<id>.json`.
+
+## Prerequisites
+
+- `mp` authenticated: `mp user retrieve`
+- The target position is held in a wallet `mp wallet list` knows about
+- `jq` and `bc` installed
+
+## Configuration
+
+Captured on first run:
+
+| Field | Notes |
+|---|---|
+| `token` | Token address. Resolve via `mp token search` if user gives a ticker |
+| `chain` | e.g. `solana`, `ethereum`, `base` |
+| `wallet` | Local wallet name |
+| `entry_price` | Cost basis the rungs are computed off — required |
+| `rungs` | Array of `{multiplier, sell_pct, fired}`. Default: `[{x: 1.5, sell: 25, fired: false}, {x: 2.0, sell: 25, fired: false}, {x: 3.0, sell: 25, fired: false}]` (hold remaining 25%) |
+| `sell_into` | Default: USDC |
+
+Compute absolute target prices once: `target = entry_price * multiplier`. Persist them so price math is consistent across fires.
+
+## Per-fire workflow
+
+```
+1. price = mp --json token retrieve --token $TOKEN --chain $CHAIN | jq '.marketData.price'
+2. balance = mp --json token balance list --wallet $WALLET_ADDR --chain $CHAIN
+            | jq --arg t $TOKEN '.items[] | select(.address==$t) | .balance.amount'
+3. If balance == 0: mark all rungs as fired or strategy as complete; log "ladder complete"; exit.
+4. crossable = rungs where fired==false AND price >= target
+5. If crossable is empty: log "holding — price $price, next rung at $next_target ($gap_pct% away)"; exit.
+6. For each crossable rung (in target order, lowest first):
+   a. sell_amount = current_balance * (rung.sell_pct / 100)
+   b. mp token swap --from-token $TOKEN --from-amount $sell_amount --to-token $SELL_INTO ...
+   c. Mark rung.fired = true. Update balance for next iteration.
+7. Report: fill price for each rung, USD realized this fire, cumulative USD realized, % of original position remaining.
+```
+
+The sell command:
+
+```bash
+mp --json token swap \
+  --wallet "$WALLET" \
+  --chain "$CHAIN" \
+  --from-token "$TOKEN" \
+  --from-amount "$SELL_AMOUNT" \
+  --to-token "$SELL_INTO"
+```
+
+## Schedule
+
+15 minutes is a reasonable default. Volatile small-caps may want 5 minutes so a fast pump doesn't blow past multiple rungs unnoticed (the strategy handles gap-ups by firing all crossed rungs in one pass — but you'd rather fire each rung close to its actual price than fire all three at one mid-pump price).
+
+## Headless reference script
+
+```bash
+#!/bin/bash
+set -euo pipefail
+MP="$(which mp)"
+ID="tp-ladder-bonk-main"
+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 ---
+TOKEN="<token-mint>"
+CHAIN="solana"
+WALLET="main"
+WALLET_ADDR="<address>"
+SELL_INTO="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+ENTRY_PRICE=0.000020   # user-provided
+
+# Initialize state on first run.
+# We compute targets via jq (not bc) because bc strips leading zeros on
+# fractional results — bc would produce ".000030" for a 0.000020 entry × 1.5,
+# which is invalid JSON. jq formats numbers correctly.
+if [ ! -f "$STATE" ]; then
+  jq -n --argjson e "$ENTRY_PRICE" '
+    {
+      entry_price: $e,
+      rungs: [
+        {target: ($e * 1.5), sell_pct: 25, fired: false},
+        {target: ($e * 2.0), sell_pct: 25, fired: false},
+        {target: ($e * 3.0), sell_pct: 25, fired: false}
+      ]
+    }
+  ' > "$STATE"
+  log "initialized ladder at entry $ENTRY_PRICE"
+fi
+
+# --- Load 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
+  log "balance is zero, ladder complete"; exit 0
+fi
+
+# --- Iterate rungs in order ---
+COUNT=$(jq '.rungs | length' "$STATE")
+for i in $(seq 0 $((COUNT-1))); do
+  FIRED=$(jq -r ".rungs[$i].fired" "$STATE")
+  TARGET=$(jq -r ".rungs[$i].target" "$STATE")
+  PCT=$(jq -r ".rungs[$i].sell_pct" "$STATE")
+  if [ "$FIRED" = "true" ] || (( $(echo "$PRICE < $TARGET" | bc -l) )); then continue; fi
+
+  CURRENT=$("$MP" --json token balance list --wallet "$WALLET_ADDR" --chain "$CHAIN" \
+    | jq --arg t "$TOKEN" '[.items[] | select(.address==$t) | .balance.amount][0] // 0')
+  SELL=$(echo "scale=8; $CURRENT * $PCT / 100" | bc -l)
+
+  log "RUNG $i: price $PRICE >= target $TARGET — selling $SELL ($PCT% of $CURRENT)"
+  RESULT=$("$MP" --json token swap \
+    --wallet "$WALLET" --chain "$CHAIN" \
+    --from-token "$TOKEN" --from-amount "$SELL" \
+    --to-token "$SELL_INTO" 2>&1) || { log "RUNG $i FAILED: $RESULT"; exit 1; }
+  log "RUNG $i OK: $RESULT"
+
+  jq ".rungs[$i].fired = true" "$STATE" > "$STATE.tmp" && mv "$STATE.tmp" "$STATE"
+done
+```
+
+## Inside an automation harness
+
+When this skill runs inside the MoonPay Agents desktop app, the harness's persistent chat session holds the rung state — no `state.json` needed. The agent reports each fire conversationally and continues to track unfired rungs across runs.
+
+## Common pitfalls
+
+- **Selling a fixed % of the original position instead of the current**. If rung 1 sold 25% of original and rung 2 also sells "25% of original," you're selling 33% of what's left. Always compute against the current balance at the moment of firing.
+- **Storing only multipliers without absolute targets**. If you recompute `entry_price * multiplier` from memory each fire and entry_price drifts (say, the agent re-asks the user), you'll fire on different prices. Persist absolute target prices once.
+- **Not handling gap-ups**. If price jumps from 1.4× entry to 2.5× entry between fires, both rung 1 and rung 2 should fire. The reference script iterates all unfired rungs — match that pattern.
+
+## Related skills
+
+- **moonpay-trading-automation** — General shell-script + cron patterns
+- **moonpay-trailing-stop** — Companion strategy for the downside
+- **moonpay-discover-tokens** — Resolve tickers to addresses
+- **moonpay-swap-tokens** — Swap syntax

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