🤖 Nexus XYZ Perp Trading Bot

Automated multi-account perpetual trading bot for Nexus XYZ — three independent strategies, unlimited accounts, per-account proxy support

╔══════════════════════════════════════════════════════════════════╗
║  Strategy 1 — Delta-Neutral      │  near-zero directional risk  ║
║  Strategy 2 — Copy Trading       │  mirror top wallets live     ║
║  Strategy 3 — Funding Arbitrage  │  harvest funding rate yields ║
║                                                                  ║
║  ✦ Multi-account  ·  Per-account proxies  ·  Async workers     ║
╚══════════════════════════════════════════════════════════════════╝

🚀 Open Nexus XYZ · 🐦 Follow Dev

---

📌 Table of Contents

• How It Works
• Multi-Account & Proxy Support
• Strategies
  • Strategy 1 — Delta-Neutral
  • Strategy 2 — Copy Trading
  • Strategy 3 — Funding Arbitrage
• Installation
• Configuration
• Running the Bot
• Running 24/7 on a VPS
• Risk Management
• Telegram Commands
• Disclaimer

---

⚡ How It Works

  Nexus XYZ perp markets update in real time
          │
          ▼  (all account workers run simultaneously)
          │
  Per account:
    • Authenticate via API key + wallet signature
    • Route all traffic through assigned proxy
    • Execute active strategy independently
    • Apply per-account risk limits
    • Report PnL and positions
          │
          ▼
  Positions managed until closed  📈
          │
          ▼
  Telegram summary per account  📱

Every account is an independent async worker with its own strategy, risk limits, and proxy. One failed connection never affects the others.

---

👥 Multi-Account & Proxy Support

How accounts are configured

All accounts live in accounts.json. Each entry has its own wallet, API credentials, active strategy, and optional proxy.

  accounts.json
  ├── Account #1  →  wallet_1 + apikey_1 + proxy_1 + strategy: delta_neutral
  ├── Account #2  →  wallet_2 + apikey_2 + proxy_2 + strategy: copy_trading
  ├── Account #3  →  wallet_3 + apikey_3 + (no proxy) + strategy: funding_arb
  └── ...unlimited accounts
          │
          ▼
  Bot spawns one async worker per account
          │
          ▼
  Workers run in parallel up to MAX_PARALLEL

accounts.json structure:

[
  {
    "id": "account_1",
    "label": "Delta hedge",
    "wallet_address": "0xYourWallet1",
    "private_key": "0xYourPrivateKey1",
    "nexus_api_key": "your_api_key_1",
    "nexus_api_secret": "your_api_secret_1",
    "strategy": "delta_neutral",
    "referral_code": "YOUR_REF",
    "proxy": "http://user:pass@host:port"
  },
  {
    "id": "account_2",
    "label": "Copy acc",
    "wallet_address": "0xYourWallet2",
    "private_key": "0xYourPrivateKey2",
    "nexus_api_key": "your_api_key_2",
    "nexus_api_secret": "your_api_secret_2",
    "strategy": "copy_trading",
    "leader_wallet": "0xLeaderWalletAddress",
    "referral_code": "YOUR_REF",
    "proxy": "socks5://user:pass@host:port"
  },
  {
    "id": "account_3",
    "label": "Funding farmer",
    "wallet_address": "0xYourWallet3",
    "private_key": "0xYourPrivateKey3",
    "nexus_api_key": "your_api_key_3",
    "nexus_api_secret": "your_api_secret_3",
    "strategy": "funding_arb",
    "referral_code": "YOUR_REF",
    "proxy": ""
  }
]

How to get Nexus XYZ API credentials

1. Go to app.nexus.xyz/trade and connect your wallet
2. Navigate to Settings → API → Generate API Key
3. Sign the message with your wallet to confirm ownership
4. Save the API Key and Secret — shown only once
5. Add them to the account entry in accounts.json

⚠️ Each account needs its own API key. Never share API secrets or private keys.

Proxy formats supported

| Format | Example | |--------|---------| | HTTP | http://user:pass@host:port | | HTTPS | https://user:pass@host:port | | SOCKS5 | socks5://user:pass@host:port | | No auth | http://host:port | | None | leave "proxy": "" |

Concurrency & safety settings

MAX_PARALLEL=5              # Max accounts trading at the same time
ACCOUNT_DELAY=15            # Seconds between launching each worker
JITTER=true                 # Random ±5s delay per order (human-like)
PROXY_TEST_ON_START=true    # Verify each proxy before trading begins
ROTATE_USER_AGENT=true      # Unique user-agent per account

---

📐 Strategies

⚖️ Strategy 1 — Delta-Neutral

Earn on volatility and funding rates while staying neutral to market direction. Profit does not depend on whether the price goes up or down.

  Open LONG on spot  +  SHORT on Nexus perp  (same asset)
              │
              ▼
  Positions hedge each other → net delta ≈ 0
              │
              ▼
  Profit comes from:
    • positive funding rate payments (perp longs pay shorts)
    • spread captured on limit-order rebalancing

How it works:

1. The bot opens equal-sized LONG (spot or low-leverage perp) and SHORT (perp) positions on the same asset.
2. Every N hours it checks delta drift from price movement and rebalances if deviation exceeds threshold.
3. When funding turns negative, positions invert (SHORT spot + LONG perp) to keep collecting.

Decision table:

| Condition | Action | |-----------|--------| | Funding rate > 0.01% | Hold SHORT on perp, collect payments | | Funding rate < -0.01% | Invert positions | | Delta drifted > 5% | Rebalance with limit orders | | High volatility detected | Reduce position size |

Config block (per account or in .env):

STRATEGY=delta_neutral
DN_SYMBOL=BTC-PERP
DN_LONG_SIZE=100            # USD in long leg
DN_SHORT_SIZE=100           # USD in short leg
DN_LEVERAGE=1               # Keep low — this is a hedged position
DN_REBALANCE_THRESHOLD=5    # % drift before rebalancing
DN_MIN_FUNDING=0.005        # Minimum funding rate to enter (%)
DN_CHECK_INTERVAL=3600      # Rebalance check every N seconds
DN_ORDER_TYPE=LIMIT         # Always limit for lower fees

💡 Tip: Works best during periods of consistently positive funding. Check Nexus XYZ's funding rate history before entering — avoid assets with erratic near-zero rates.

---

📡 Strategy 2 — Copy Trading

The bot polls a target wallet's positions on Nexus XYZ every few seconds. When a change is detected it immediately mirrors the trade on the copying account with a proportionally scaled size.

  Leader opens BTC-PERP LONG $5,000
              │
              ▼  (detected via polling)
              │
  Bot calculates size:
  (ourEquity $1,000 / leaderEquity $10,000) × $5,000 × multiplier 1.0 = $500
  MAX_POSITION_PERCENT cap applied if needed
              │
              ▼
  Account opens BTC-PERP LONG $500  ✅
              │
              ▼
  Leader reduces or closes → bot mirrors proportionally ✅

Choosing who to copy:

Each account in accounts.json specifies its own leader_wallet. Run different leaders across accounts to diversify.

✅ Good wallets to copy:

• Consistent PnL over weeks, not days
• Holds positions for hours or longer (swing style)
• 1–5 trades per day
• Clear directional bias, not constantly reversing

❌ Avoid:

• HFT / high-frequency wallets — impossible to keep up, slippage destroys edge
• Market makers — positions on both sides simultaneously
• Scalpers — seconds-to-minutes holds, orders won't fill in time
• Leverage flippers — change leverage constantly to distort size calculation

Config block:

STRATEGY=copy_trading
LEADER_WALLET=0xLeaderWalletAddress     # Set per account in accounts.json
COPY_RATIO=1.0                          # Equity-based ratio multiplier
MAX_LEVERAGE=20                         # Cap on copied leverage
MAX_POSITION_SIZE_PERCENT=50            # Max single position as % of equity
MIN_NOTIONAL=5                          # Skip trades smaller than $N
MAX_CONCURRENT_POSITIONS=10             # Max open positions at once
BLOCKED_SYMBOLS=                        # Comma-separated symbols to skip
SYNC_INTERVAL=5                         # Poll leader positions every N seconds

---

💸 Strategy 3 — Funding Arbitrage

The bot scans all Nexus XYZ perp markets for anomalously high funding rates and opens positions to collect payments with minimal directional exposure.

  Scan all Nexus perps → find funding rate above entry threshold
              │
              ▼
  Open position AGAINST the funding direction:
    • Funding > 0  →  SHORT  (longs pay shorts each cycle)
    • Funding < 0  →  LONG   (shorts pay longs each cycle)
              │
              ▼
  Collect funding payment each cycle
              │
              ▼
  Exit when any trigger fires:
    • Rate normalizes below exit_threshold
    • Target PnL reached
    • Position held longer than max_hold_hours
    • Unrealized loss exceeds stop_loss

Example scenario:

BTC-PERP funding = +0.05% per 8h
Bot opens $100 SHORT on BTC-PERP  (limit order)
  → receives $0.05 every 8 hours
  → over 48 hours = $0.30 on $100 deployed
  → annualized ≈ 27% APR  (if rate holds)
Optiona