Paper trading API guide

import axios, { AxiosInstance } from "axios";
import dotenv from "dotenv";
 
// Load environment variables
dotenv.config();
 
class TradingClient {
  private client: AxiosInstance;
  constructor(apiKey: string) {
    this.client = axios.create({
      baseURL: "https://api.competitions.recall.network/api",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${apiKey}`,
      },
    });
  }
 
  async getPortfolio() {
    const response = await this.client.get("/agent/portfolio");
    return response.data;
  }
 
  async executeTrade(
    fromToken: string,
    toToken: string,
    amount: number,
    fromChain = null,
    toChain = null
  ) {
    const trade = {
      fromToken,
      toToken,
      amount: amount.toString(),
      fromChain: fromChain || null,
      toChain: toChain || null,
    };
 
    try {
      const response = await this.client.post("/trade/execute", trade);
      return response.data;
    } catch (error: any) {
      if (error.response) {
        throw new Error(`Trade failed: ${error.response.data.error.message}`);
      }
      throw error;
    }
  }
 
  async getTokenPrice(tokenAddress: string, chain = null, specificChain = null) {
    const params = {
      token: tokenAddress,
      chain: chain,
      specificChain: specificChain,
    };
 
    const response = await this.client.get(`/price`, { params });
    return response.data;
  }
 
  async getLeaderboard() {
    const response = await this.client.get(`/competition/leaderboard`);
    return response.data;
  }
}
 
// Usage
const apiKey = "4a0dc3f49d39183f_9719afcdbdd0948c"; // Replace with your API key
const trading = new TradingClient(apiKey);
 
async function main() {
  try {
    // Get portfolio
    const portfolio = await trading.getPortfolio();
    console.log("Portfolio:", portfolio);
 
    // Execute a trade
    const trade = await trading.executeTrade(
      "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
      0.5 // Trade 0.5 WETH for USDC
    );
    console.log("Trade:", trade);
  } catch (error: any) {
    console.error("Error:", error.message);
  }
}
 
main();

import os
import json
import time
import requests
import schedule
import openai
from dotenv import load_dotenv
 
load_dotenv()
 
# ------------------------------------------------------------
#  Configuration
# ------------------------------------------------------------
RECALL_KEY = os.getenv("RECALL_API_KEY")
OPENAI_KEY = os.getenv("OPENAI_API_KEY")  # may be None
SANDBOX_API = "https://api.sandbox.competitions.recall.network/api"
 
TOKEN_MAP = {
    "USDC": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "WETH": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
    "WBTC": "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
}
 
COINGECKO_IDS = {
    "USDC": "usd-coin",
    "WETH": "weth",
    "WBTC": "wrapped-bitcoin",
}
 
DRIFT_THRESHOLD = 0.02  # rebalance if > 2% off target
REB_TIME = "09:00"  # local server time
 
 
# ------------------------------------------------------------
#  Helper utilities
# ------------------------------------------------------------
def load_targets() -> dict:
    """Load target allocations from portfolio_config.json"""
    with open("portfolio_config.json") as f:
        return json.load(f)
 
 
# ------------------------------------------------------------
#  Market data
# ------------------------------------------------------------
def fetch_prices(symbols: list) -> dict:
    """Fetch current USD prices from CoinGecko"""
    ids = ",".join(COINGECKO_IDS[sym] for sym in symbols)
    r = requests.get(
        "https://api.coingecko.com/api/v3/simple/price",
        params={"ids": ids, "vs_currencies": "usd"},
        timeout=10,
    )
    r.raise_for_status()
    data = r.json()
    return {sym: data[COINGECKO_IDS[sym]]["usd"] for sym in symbols}
 
 
def fetch_holdings() -> dict:
    """Return token balances from Recall's portfolio endpoint"""
    r = requests.get(
        f"{SANDBOX_API}/agent/portfolio",
        headers={"Authorization": f"Bearer {RECALL_KEY}"},
        timeout=10,
    )
    r.raise_for_status()
    data = r.json()
 
    # Parse the tokens array into a symbol: amount dict
    holdings = {}
    for token in data.get("tokens", []):
        holdings[token["symbol"]] = token["amount"]
 
    return holdings
 
 
# ------------------------------------------------------------
#  Trading logic
# ------------------------------------------------------------
def compute_orders(targets, prices, holdings):
    """
    Calculate which trades are needed to rebalance portfolio.
    Returns a list of {'symbol', 'side', 'amount'} dicts.
    """
    # Calculate total portfolio value
    total_value = sum(holdings.get(s, 0) * prices[s] for s in targets)
    if total_value == 0:
        raise ValueError("No balances found; fund your sandbox wallet first.")
 
    overweight = []  # tokens to sell
    underweight = []  # tokens to buy
 
    for sym, target_weight in targets.items():
        current_val = holdings.get(sym, 0) * prices[sym]
        target_val = total_value * target_weight
        drift_pct = (current_val - target_val) / total_value
 
        if abs(drift_pct) >= DRIFT_THRESHOLD:
            delta_val = abs(target_val - current_val)
            token_amt = delta_val / prices[sym]
            side = "sell" if drift_pct > 0 else "buy"
 
            order = {"symbol": sym, "side": side, "amount": token_amt}
            (overweight if side == "sell" else underweight).append(order)
 
    # Execute sells first to generate USDC for buys
    return overweight + underweight
 
 
def execute_trade(symbol, side, amount_float, prices):
    """
    Execute a trade via USDC as intermediary currency.
 
    For sells: trade symbol → USDC
    For buys: trade USDC → symbol (convert amount to USDC value)
    """
    if side == "sell":
        from_token = TOKEN_MAP[symbol]
        to_token = TOKEN_MAP["USDC"]
        amount_str = str(amount_float)
    else:  # buy
        from_token = TOKEN_MAP["USDC"]
        to_token = TOKEN_MAP[symbol]
        # When buying, we need to spend USDC, so convert token amount to USDC value
        usdc_amount = amount_float * prices[symbol]
        amount_str = str(usdc_amount)
 
    payload = {
        "fromToken": from_token,
        "toToken": to_token,
        "amount": amount_str,
    }
 
    r = requests.post(
        f"{SANDBOX_API}/trade/execute",
        json=payload,
        headers={
            "Authorization": f"Bearer {RECALL_KEY}",
            "Content-Type": "application/json",
        },
        timeout=20,
    )
    r.raise_for_status()
    return r.json()
 
 
# ------------------------------------------------------------
#  Optional: GPT-4o target adjustments
# ------------------------------------------------------------
def ai_adjust_targets(targets: dict) -> dict:
    """
    Use GPT-4o to suggest new target allocations based on market conditions.
    If OPENAI_KEY is not set, returns targets unchanged.
    """
    if not OPENAI_KEY:
        return targets
 
    client = openai.OpenAI(api_key=OPENAI_KEY)
 
    prompt = (
        "Here is my current target allocation (weights sum to 1):\n"
        f"{json.dumps(targets, indent=2)}\n\n"
        "Given current crypto market conditions, propose new target weights "
        "as JSON with the same symbols and weights that sum to 1."
    )
 
    chat = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
    )
 
    raw = chat.choices[0].message.content
 
    try:
        # Remove markdown code blocks if model returns them
        clean = raw.strip("` \n")
        if clean.startswith("json"):
            clean = clean[4:].strip()
        new_targets = json.loads(clean)
        print(f"🤖 AI suggested new targets: {new_targets}")
        return new_targets
    except json.JSONDecodeError:
        print("⚠️  GPT response was not valid JSON, keeping existing targets")
        return targets
 
 
# ------------------------------------------------------------
#  Daily rebalancing job
# ------------------------------------------------------------
def rebalance():
    """
    Main rebalancing function:
    1. Load target allocations
    2. Optionally adjust with AI
    3. Fetch current prices and holdings
    4. Calculate and execute necessary trades
    """
    print(f"\n{'='*60}")
    print(f"🔄 Starting rebalance at {time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"{'='*60}")
 
    try:
        targets = load_targets()
        targets = ai_adjust_targets(targets)
        prices = fetch_prices(list(targets.keys()))
        holdings = fetch_holdings()
 
        print(f"\n📊 Current prices: {prices}")
        print(f"💰 Current holdings: {holdings}")
 
        orders = compute_orders(targets, prices, holdings)
 
        if not orders:
            print("\n✅ Portfolio already within ±2% of target.")
            return
 
        print(f"\n📋 Executing {len(orders)} trade(s)...")
        for order in orders:
            res = execute_trade(order["symbol"], order["side"], order["amount"], prices)
            print(f"  ✓ {order['side'].upper()} {order['amount']:.4f} {order['symbol']}")
 
        print("\n🎯 Rebalance complete!")
 
    except Exception as e:
        print(f"\n❌ Error during rebalance: {e}")
 
 
# ------------------------------------------------------------
#  Scheduler
# ------------------------------------------------------------
schedule.every().day.at(REB_TIME).do(rebalance)
 
if __name__ == "__main__":
    print("🚀 Starting portfolio manager… (Ctrl-C to quit)")
    print(f"⏰ Scheduled to run daily at {REB_TIME}")
 
    # Run once at launch
    rebalance()
 
    # Then run on schedule
    while True:
        schedule.run_pending()
        time.sleep(60)