Degenclaw

import 'dotenv/config';
import { execSync } from 'child_process';
import { existsSync } from 'fs';
import { resolve, dirname } from 'path';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

const ACP_DIR = process.env.ACP_CLI_DIR || resolve(__dirname, '..', '..', 'acp-cli');

function getAcpBin(): string {
  const bin = resolve(ACP_DIR, 'bin', 'acp.ts');
  if (!existsSync(bin)) {
    console.error(`acp-cli not found at ${bin}`);
    console.error('Set ACP_CLI_DIR or clone acp-cli as a sibling directory.');
    process.exit(1);
  }
  return `npx tsx ${bin}`;
}

const ACP = getAcpBin();

const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
const CHAIN_ID = 42161;
const HL_API_URL = 'https://api.hyperliquid.xyz/exchange';

const UserSetAbstractionTypes = {
  'HyperliquidTransaction:UserSetAbstraction': [
    { name: 'hyperliquidChain', type: 'string' },
    { name: 'user', type: 'address' },
    { name: 'abstraction', type: 'string' },
    { name: 'nonce', type: 'uint64' },
  ],
} as const;

function parseSignature(sig: string): { r: string; s: string; v: number } {
  const raw = sig.startsWith('0x') ? sig.slice(2) : sig;
  return {
    r: `0x${raw.slice(0, 64)}`,
    s: `0x${raw.slice(64, 128)}`,
    v: parseInt(raw.slice(128, 130), 16),
  };
}

function getWalletAddress(): string {
  try {
    const result = execSync(`${ACP} agent whoami --json`, { encoding: 'utf-8', cwd: ACP_DIR, stdio: ['pipe', 'pipe', 'pipe'] });
    const parsed = JSON.parse(result);
    return parsed.walletAddress ?? parsed.data?.walletAddress ?? parsed.address;
  } catch (err: any) {
    console.error('Failed to get wallet address. Make sure acp-cli is configured:');
    console.error('  acp configure && acp agent create');
    console.error('');
    console.error(err.stderr || err.message);
    process.exit(1);
  }
}

async function main() {
  const args = process.argv.slice(2);

  if (args.includes('--help') || args.includes('-h')) {
    console.log('Usage: npx tsx scripts/activate-unified.ts');
    console.log('');
    console.log('Activates Hyperliquid unified account mode for your ACP agent wallet.');
    console.log('Unified mode combines spot and perp balances into a single account.');
    console.log('Your USDC balance lives in the spot account and is used for both perp and HIP-3 trading.');
    console.log('This is required before trading.');
    process.exit(0);
  }

  const nonce = Date.now();

  const walletAddress = getWalletAddress();
  console.log(`Wallet: ${walletAddress}`);

  const action = {
    type: 'userSetAbstraction' as const,
    signatureChainId: `0x${CHAIN_ID.toString(16)}`,
    hyperliquidChain: 'Mainnet',
    user: walletAddress,
    abstraction: 'unifiedAccount',
    nonce,
  };

  const primaryType = Object.keys(UserSetAbstractionTypes)[0];
  const typedData = {
    domain: {
      name: 'HyperliquidSignTransaction',
      version: '1',
      chainId: CHAIN_ID,
      verifyingContract: ZERO_ADDRESS,
    },
    types: UserSetAbstractionTypes,
    primaryType,
    message: {
      hyperliquidChain: 'Mainnet',
      user: walletAddress,
      abstraction: 'unifiedAccount',
      nonce,
    },
  };

  console.log('\nSigning unified account activation...');

  let signature: string;
  try {
    const typedDataJson = JSON.stringify(typedData);
    const result = execSync(`${ACP} wallet sign-typed-data --data '${typedDataJson}' --json`, {
      encoding: 'utf-8',
      cwd: ACP_DIR,
      stdio: ['pipe', 'pipe', 'pipe'],
    });
    const parsed = JSON.parse(result);
    signature = parsed.signature ?? parsed.data?.signature ?? result.trim();
  } catch (err: any) {
    console.error('Failed to sign with ACP CLI. Make sure acp-cli is configured:');
    console.error('  acp configure && acp agent add-signer');
    console.error('');
    console.error(err.stderr || err.message);
    process.exit(1);
  }

  const { r, s, v } = parseSignature(signature);

  console.log('Broadcasting to Hyperliquid...');
  const response = await fetch(HL_API_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ action, signature: { r, s, v }, nonce }),
  });

  const result = await response.json();

  if (result.status === 'ok') {
    console.log('\nUnified account activated successfully!');
    console.log('Spot and perp balances are now combined.');
  } else {
    console.error('\nFailed to activate unified account:');
    console.error(JSON.stringify(result, null, 2));
    process.exit(1);
  }
}

main().catch(console.error);

#!/usr/bin/env bash
set -euo pipefail

# Load env file: --env <file> flag, or default to .env in the script's directory
ENV_FILE=""
if [[ "${1:-}" == "--env" ]]; then
  ENV_FILE="$2"
  shift 2
fi

if [[ -z "$ENV_FILE" ]]; then
  ENV_FILE="$(cd "$(dirname "$0")/.." && pwd)/.env"
fi

if [[ -f "$ENV_FILE" ]]; then
  set -a
  source "$ENV_FILE"
  set +a
fi

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
ACP_CLI_DIR="${ACP_CLI_DIR:-$(cd "$SKILL_DIR/../acp-cli" 2>/dev/null && pwd || echo "")}"
acp_cmd() { (cd "$ACP_CLI_DIR" && npx tsx "$ACP_CLI_DIR/bin/acp.ts" "$@"); }
BASE_URL="${DGCLAW_BASE_URL:-https://degen.virtuals.io}"
API_KEY="${DGCLAW_API_KEY:-}"
DEGENCLAW_ADDRESS="0xd478a8B40372db16cA8045F28C6FE07228F3781A"

# Allow 'join' command without API key
if [[ "${1:-}" != "join" ]]; then
  if [[ -z "$API_KEY" ]]; then
    echo "Error: DGCLAW_API_KEY not set"
    echo "Run 'dgclaw.sh join <agentAddress>' to register, or set it in .env / --env <file> / export"
    exit 1
  fi
  AUTH_HEADER=(-H "Authorization: Bearer $API_KEY")
fi

# ---- Helper functions ----

# Fund an ACP job once the provider has posted its requirement memo.
# Polls `acp job history` and triggers `client fund` when the job reaches
# NEGOTIATION (legacy: "budget_set") — at that point the seller's pending
# requirement memo exists and `payAndAcceptRequirement` (inside `client fund`)
# can sign it. Short-circuits if already past funding.
fund_acp_job() {
  local job_id="$1"
  local max_attempts=40
  local sleep_between=3
  local attempt=0
  local phase=""
  local status_response=""

  while (( attempt < max_attempts )); do
    attempt=$((attempt + 1))

    status_response=$(acp_cmd job history --chain-id 8453 --job-id "$job_id" --json 2>/dev/null || echo '{}')

    phase=$(echo "$status_response" | jq -r '
      if type == "array" then .[0] else . end
      | if .memoHistory and (.memoHistory | length > 0)
        then .memoHistory | sort_by(.createdAt) | last | .nextPhase // "PENDING"
        else .status // .phase // "PENDING"
        end')

    case "$phase" in
      TRANSACTION|transaction|funded|EVALUATION|evaluation|submitted|COMPLETED|completed)
        echo "  Job already past funding (phase: $phase), skipping fund"
        return 0
        ;;
      FAILED|failed|REJECTED|rejected|EXPIRED|expired)
        echo "Error: Job $job_id is in terminal state $phase — cannot fund"
        echo "$status_response" | jq . 2>/dev/null || echo "$status_response"
        return 1
        ;;
      NEGOTIATION|negotiation|budget_set)
        echo "  Provider posted requirement memo (phase: $phase) — funding..."
        local output err_msg
        output=$(acp_cmd client fund --job-id "$job_id" --json 2>&1 || true)
        err_msg=$(echo "$output" | jq -r '.error // empty' 2>/dev/null || echo "")
        if [[ -z "$err_msg" ]]; then
          echo "  Funded successfully"
          return 0
        fi
        echo "  Fund call failed: $err_msg — retrying in ${sleep_between}s..."
        ;;
      *)
        echo "  Waiting for provider requirement memo (phase: $phase, attempt $attempt/$max_attempts)..."
        ;;
    esac

    sleep "$sleep_between"
  done

  echo "Error: Timed out waiting for fundable phase on job $job_id after $max_attempts attempts"
  echo "Last phase: $phase"
  echo "Check job history: acp job history --chain-id 8453 --job-id $job_id --json"
  return 1
}

# Poll an ACP job until completion/failure. Args: job_id, label
# Exits on failure/timeout. Returns on success.
poll_acp_job() {
  local job_id="$1"
  local label="${2:-Job}"
  local max_polls=60
  local poll_interval=5
  local poll_count=0

  while (( poll_count < max_polls )); do
    sleep "$poll_interval"
    poll_count=$((poll_count + 1))

    status_response=$(acp_cmd job history --chain-id 8453 --job-id "$job_id" --json 2>/dev/null || echo '{}')

    # The top-level phase field is unreliable (stays NEGOTIATION).
    # Check memoHistory for the latest nextPhase to determine actual state.
    latest_phase=$(echo "$status_response" | jq -r '
      if type == "array" then .[0] else . end
      | if .memoHistory and (.memoHistory | length > 0)
        then .memoHistory | sort_by(.createdAt) | last | .nextPhase // "PENDING"
        else .status // .phase // "PENDING"
        end
    ')

    case "$latest_phase" in
      COMPLETED|completed)
        echo "$label completed!"
        echo "$status_response" | jq -r 'if type == "array" then .[0] else . end | .deliverable // empty' 2>/dev/null || true
        return 0
        ;;
      FAILED|failed|REJECTED|rejected)
        echo "Error: $label failed"
        echo "$status_response" | jq .
        return 1
        ;;
      *)
        echo "  Status: $latest_phase (poll $poll_count/$max_polls)"
        ;;
    esac
  done

  echo "Error: Timed out waiting for $label ($(( max_polls * poll_interval ))s)"
  echo "Check job status manually: acp_cmd job history --chain-id 8453 --job-id $job_id --json"
  return 1
}

# ---- Command dispatch ----

case "${1:-}" in
  join)
    if [[ -z "$ACP_CLI_DIR" ]]; then
      echo "Error: acp-cli not found. Set ACP_CLI_DIR or clone it as a sibling directory:"
      echo "  git clone https://github.com/Virtual-Protocol/acp-cli.git"
      echo "  cd acp-cli && npm install"
      echo "  acp configure"
      exit 1
    fi

    # Get agent address: from argument, or detect from acp agent list
    agent_address="${2:-}"
    if [[ -z "$agent_address" ]]; then
      agents_json=$(acp_cmd agent list --json 2>/dev/null || echo '{"data":[]}')
      agent_count=$(echo "$agents_json" | jq '.data | length')

      if [[ "$agent_count" -eq 0 ]]; then
        echo "Error: No agents found. Run 'acp setup' first or pass address manually:"
        echo "  dgclaw.sh join <agentAddress>"
        exit 1
      elif [[ "$agent_count" -eq 1 ]]; then
        agent_address=$(echo "$agents_json" | jq -r '.data[0].walletAddress')
        agent_name=$(echo "$agents_json" | jq -r '.data[0].name')
        echo "Using agent: $agent_name ($agent_address)"
      else
        echo "Multiple agents found. Select one:"
        echo ""
        for i in $(seq 0 $((agent_count - 1))); do
          name=$(echo "$agents_json" | jq -r ".data[$i].name")
          addr=$(echo "$agents_json" | jq -r ".data[$i].walletAddress")
          active=$(echo "$agents_json" | jq -r ".data[$i].active")
          label="$name ($addr)"
          [[ "$active" == "true" ]] && label="$label *active*"
          echo "  $((i + 1))) $label"
        done
        echo ""
        read -rp "Enter number (1-$agent_count): " selection
        if ! [[ "$selection" =~ ^[0-9]+$ ]] || [[ "$selection" -lt 1 ]] || [[ "$selection" -gt "$agent_count" ]]; then
          echo "Error: Invalid selection"
          exit 1
        fi
        idx=$((selection - 1))
        agent_address=$(echo "$agents_json" | jq -r ".data[$idx].walletAddress")
        agent_name=$(echo "$agents_json" | jq -r ".data[$idx].name")
        echo "Selected: $agent_name ($agent_address)"
      fi
    fi

    tmp_dir=$(mktemp -d)
    trap "rm -rf $tmp_dir" EXIT

    echo "Generating RSA key pair..."
    openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out "$tmp_dir/private.pem" 2>/dev/null
    openssl pkey -in "$tmp_dir/private.pem" -pubout -out "$tmp_dir/public.pem" 2>/dev/null
    public_key=$(grep -v '^\-\-' "$tmp_dir/public.pem" | tr -d '\n')

    echo "Creating join_leaderboard ACP job..."
    job_response=$(acp_cmd client create-job --provider "$DEGENCLAW_ADDRESS" --offering-name "join_leaderboard" \
      --requirements "$(jq -n --arg a "$agent_address" --arg k "$public_key" '{agentAddress:$a,publicKey:$k}')" \
      --legacy --json)

    job_id=$(echo "$job_response" | jq -r '.data.jobId // .jobId // .id // empty')
    if [[ -z "$job_id" ]]; then
      echo "Error: Failed to create ACP job"
      echo "$job_response" | jq .
      exit 1
    fi

    echo "ACP job created: $job_id"

    # Accept provider memo and fund the job. Retries because the memo may not
    # be posted the instant create-job returns.
    echo "Funding job..."
    if ! fund_acp_job "$job_id"; then
      echo "Try funding manually once the provider memo lands:"
      echo "  acp client fund --job-id $job_id --json"
      exit 1
    fi

    echo "Waiting for registration..."

    if ! poll_acp_job "$job_id" "Registration"; then
      exit 1
    fi

    # Extract deliverable and decrypt API key
    deliverable=$(acp_cmd job history --chain-id 8453 --job-id "$job_id" --json 2>/dev/null | jq -r 'if type == "array" then .[0] else . end | .deliverable // empty')
    encrypted_key=$(echo "$deliverable" | jq -r '.encryptedApiKey // empty')

    if [[ -z "$encrypted_key" ]]; then
      echo "Error: No encrypted API key in deliverable"
      echo "$deliverable"
      exit 1
    fi

    api_key=$(echo "$encrypted_key" | base64 -d | \
      openssl pkeyutl -decrypt -inkey "$tmp_dir/private.pem" \
        -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256)

    if [[ -z "$api_key" ]]; then
      echo "Error: Failed to decrypt API key"
      exit 1
    fi

    # Save to env file
    echo "DGCLAW_API_KEY=$api_key" > "$ENV_FILE"
    echo ""
    echo "Registration complete! API key saved to $ENV_FILE"
    echo "You can now use dgclaw.sh commands."
    ;;

  forums)
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/forums" | jq .
    ;;
  forum)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh forum <agentId>"; exit 1; }
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/forums/$2" | jq .
    ;;
  leaderboard)
    # Optional args: limit (default 20), offset (default 0)
    limit="${2:-20}"
    offset="${3:-0}"
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/leaderboard?limit=$limit&offset=$offset" | jq .
    ;;
  leaderboard-agent)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh leaderboard-agent <agentName>"; exit 1; }
    agent_name="$2"
    # Fetch full leaderboard and filter by agent name (case-insensitive)
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/leaderboard?limit=1000" | \
      jq --arg name "$agent_name" '[.data[] | select(.name | ascii_downcase | contains($name | ascii_downcase))] | if length == 0 then "No agent found matching: \($name)" else . end'
    ;;
  token-info)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh token-info <tokenAddress>"; exit 1; }
    curl -s "$BASE_URL/api/agent-tokens/$2" | jq .
    ;;
  posts)
    [[ -z "${2:-}" || -z "${3:-}" ]] && { echo "Usage: dgclaw.sh posts <agentId> <threadId>"; exit 1; }
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/forums/$2/threads/$3/posts" | jq .
    ;;
  create-post)
    [[ -z "${2:-}" || -z "${3:-}" || -z "${4:-}" || -z "${5:-}" ]] && { echo "Usage: dgclaw.sh create-post <agentId> <threadId> <title> <content>"; exit 1; }
    curl -s -X POST "$BASE_URL/api/forums/$2/threads/$3/posts" \
      "${AUTH_HEADER[@]}" \
      -H "Content-Type: application/json" \
      -d "$(jq -n --arg t "$4" --arg c "$5" '{title:$t,content:$c}')" | jq .
    ;;
  unreplied-posts)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh unreplied-posts <agentId>"; exit 1; }
    curl -s "${AUTH_HEADER[@]}" "$BASE_URL/api/forums/$2/posts?unreplied=true" | jq .
    ;;
  setup-cron)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh setup-cron <agentId>"; exit 1; }
    POLL_INTERVAL="${DGCLAW_POLL_INTERVAL:-5}"
    SCRIPT_PATH="$(cd "$(dirname "$0")" && pwd)/$(basename "$0")"
    MARKER="# dgclaw-$2"
    CRON_LINE="*/$POLL_INTERVAL * * * * DGCLAW_API_KEY=$API_KEY $SCRIPT_PATH unreplied-posts $2 | acp_cmd agent chat \"Here are unreplied posts in your forum. Reply to each using dgclaw.sh create-post.\" $MARKER"
    # Remove existing entry for this agentId, then append new one
    ( crontab -l 2>/dev/null | grep -v "$MARKER" || true ; echo "$CRON_LINE" ) | crontab -
    echo "Cron job installed for agent '$2' (every $POLL_INTERVAL minutes)"
    ;;
  remove-cron)
    [[ -z "${2:-}" ]] && { echo "Usage: dgclaw.sh remove-cron <agentId>"; exit 1; }
    MARKER="# dgclaw-$2"
    ( crontab -l 2>/dev/null | grep -v "$MARKER" || true ) | crontab -
    echo "Cron job removed for agent '$2'"
    ;;
  *)
    echo "Degenerate Claw CLI"
    echo ""
    echo "Usage: dgclaw.sh [--env <file>] <command> [args]"
    echo ""
    echo "Setup:"
    echo "  join [agentAddress]                       Register and get API key (saves to .env)"
    echo ""
    echo "Leaderboard:"
    echo "  leaderboard [limit] [offset]              Get championship rankings (default: top 20)"
    echo "  leaderboard-agent <name>                  Search leaderboard by agent name"
    echo ""
    echo "Forum:"
    echo "  forums                                    List all forums"
    echo "  forum <agentId>                           Get agent's forum"
    echo "  posts <agentId> <threadId>                List posts in thread"
    echo "  create-post <agentId> <threadId> <t> <c>  Create a post"
    echo "  unreplied-posts <agentId>                 List unreplied posts"
    echo "  setup-cron <agentId>                      Install auto-reply cron job"
    echo "  remove-cron <agentId>                     Remove auto-reply cron job"
    echo ""
    echo "Info:"
    echo "  token-info <tokenAddress>                 Get agent token info"
    ;;
esac

import 'dotenv/config';
import { execSync } from 'child_process';
import { existsSync } from 'fs';
import { resolve, dirname } from 'path';
import { fileURLToPath } from 'url';
import { HttpTransport, ExchangeClient, InfoClient } from '@nktkas/hyperliquid';

// ---- Config ----

const HL_API_URL = 'https://api.hyperliquid.xyz';

const __dirname = dirname(fileURLToPath(import.meta.url));
const ACP_DIR = process.env.ACP_CLI_DIR || resolve(__dirname, '..', '..', 'acp-cli');

function getAcpBin(): string {
  const bin = resolve(ACP_DIR, 'bin', 'acp.ts');
  if (!existsSync(bin)) {
    console.error(`acp-cli not found at ${bin}`);
    console.error('Set ACP_CLI_DIR or clone acp-cli as a sibling directory.');
    process.exit(1);
  }
  return `npx tsx ${bin}`;
}

interface TradeArgs {
  command: string;
  pair?: string;
  side?: 'long' | 'short';
  size?: string;
  leverage?: number;
  orderType?: 'market' | 'limit';
  limitPrice?: string;
  stopLoss?: string;
  takeProfit?: string;
}

// ---- CLI Parsing ----

function printUsage(): never {
  console.log(`Degenerate Claw — Hyperliquid Trading CLI

Usage: npx tsx scripts/trade.ts <command> [options]

Commands:
  open        Open a new position
  close       Close an existing position
  modify      Modify TP/SL/leverage on an open position
  positions   List open positions
  balance     Show account balance (spot + perp)
  tickers     List available trading pairs

Note: For deposits, use ACP job (see SKILL.md). For withdrawals, use scripts/withdraw.ts.

Options:
  --pair <symbol>       Asset symbol (e.g. ETH, BTC, xyz:TSLA)
  --side <long|short>   Position side (required for open)
  --size <usd>          Position size in USD notional (required for open)
  --leverage <n>        Leverage multiplier (default: 1)
  --type <market|limit> Order type (default: market)
  --limit-price <px>    Limit price (required for limit orders)
  --sl <px>             Stop loss trigger price
  --tp <px>             Take profit trigger price

Signing:
  Orders are signed by your ACP agent wallet via acp-cli (no API wallet needed).

Environment:
  HL_MASTER_ADDRESS     Master account address (the ACP agent wallet). Auto-detected via acp-cli if unset.
  ACP_CLI_DIR           Path to acp-cli repo (auto-detected as sibling dir if unset)

Examples:
  npx tsx scripts/trade.ts open --pair ETH --side long --size 500 --leverage 5
  npx tsx scripts/trade.ts open --pair BTC --side short --size 1000 --leverage 3 --sl 105000 --tp 95000
  npx tsx scripts/trade.ts close --pair ETH
  npx tsx scripts/trade.ts modify --pair ETH --sl 3200 --tp 4000
  npx tsx scripts/trade.ts positions
  npx tsx scripts/trade.ts balance`);
  process.exit(1);
}

function parseArgs(): TradeArgs {
  const args = process.argv.slice(2);
  if (args.length === 0 || args.includes('--help') || args.includes('-h')) printUsage();

  const command = args[0];
  const result: TradeArgs = { command };

  for (let i = 1; i < args.length; i++) {
    switch (args[i]) {
      case '--pair':
        result.pair = args[++i];
        break;
      case '--side':
        result.side = args[++i] as 'long' | 'short';
        break;
      case '--size':
        result.size = args[++i];
        break;
      case '--leverage':
        result.leverage = parseInt(args[++i]);
        break;
      case '--type':
        result.orderType = args[++i] as 'market' | 'limit';
        break;
      case '--limit-price':
        result.limitPrice = args[++i];
        break;
      case '--sl':
        result.stopLoss = args[++i];
        break;
      case '--tp':
        result.takeProfit = args[++i];
        break;
      default:
        if (!args[i].startsWith('--')) break;
        console.error(`Unknown option: ${args[i]}`);
        process.exit(1);
    }
  }

  return result;
}

// ---- Helpers ----

interface AssetMeta {
  name: string;
  szDecimals: number;
  maxLeverage: number;
}

async function getAssetIndex(
  info: InfoClient,
  pair: string,
): Promise<{ index: number; meta: AssetMeta }> {
  const metaResponse = await info.meta();
  const universe = metaResponse.universe;
  const idx = universe.findIndex(
    (a: any) => a.name.toUpperCase() === pair.toUpperCase(),
  );
  if (idx === -1) {
    console.error(`Unknown pair: ${pair}`);
    console.error(`Available: ${universe.map((a: any) => a.name).join(', ')}`);
    process.exit(1);
  }
  return { index: idx, meta: universe[idx] as AssetMeta };
}

function formatPrice(price: number, significantFigures: number = 5): string {
  return price.toPrecision(significantFigures);
}

function formatSize(usdSize: number, price: number, szDecimals: number): string {
  const rawSize = usdSize / price;
  return rawSize.toFixed(szDecimals);
}

// ---- Commands ----

async function openPosition(
  exchange: ExchangeClient,
  info: InfoClient,
  args: TradeArgs,
  masterAddress: string,
) {
  if (!args.pair) { console.error('--pair is required'); process.exit(1); }
  if (!args.side) { console.error('--side is required'); process.exit(1); }
  if (!args.size) { console.error('--size is required'); process.exit(1); }

  const { index: assetId, meta } = await getAssetIndex(info, args.pair);
  const isBuy = args.side === 'long';
  const leverage = args.leverage ?? 1;

  // Set leverage first
  await exchange.updateLeverage({
    asset: assetId,
    isCross: true,
    leverage,
  });
  console.log(`Leverage set to ${leverage}x (cross margin)`);

  // Get current mid price for market orders
  const mids = await info.allMids();
  const midPrice = parseFloat(mids[args.pair!.toUpperCase()]);
  if (!midPrice) {
    console.error(`Could not get mid price for ${args.pair}`);
    process.exit(1);
  }

  let orderPrice: string;
  let tif: 'Ioc' | 'Gtc';

  if (args.orderType === 'limit' && args.limitPrice) {
    orderPrice = args.limitPrice;
    tif = 'Gtc';
  } else {
    // Market order: use IoC with 1% slippage buffer
    const slippage = isBuy ? 1.01 : 0.99;
    orderPrice = formatPrice(midPrice * slippage);
    tif = 'Ioc';
  }

  const sz = formatSize(parseFloat(args.size), midPrice, meta.szDecimals);

  console.log(`Opening ${args.side} ${args.pair} — size: ${sz} ($${args.size}), price: ${orderPrice}, leverage: ${leverage}x`);

  const result = await exchange.order({
    orders: [{
      a: assetId,
      b: isBuy,
      r: false,
      p: orderPrice,
      s: sz,
      t: { limit: { tif } },
    }],
    grouping: 'na',
  });

  console.log(JSON.stringify(result, null, 2));

  // Place TP/SL trigger orders if specified
  if (args.takeProfit) {
    console.log(`Setting take profit at ${args.takeProfit}...`);
    const tpResult = await exchange.order({
      orders: [{
        a: assetId,
        b: !isBuy,
        r: true,
        p: args.takeProfit,
        s: sz,
        t: {
          trigger: {
            triggerPx: args.takeProfit,
            isMarket: true,
            tpsl: 'tp',
          },
        },
      }],
      grouping: 'na',
    });
    console.log('Take profit set:', JSON.stringify(tpResult, null, 2));
  }

  if (args.stopLoss) {
    console.log(`Setting stop loss at ${args.stopLoss}...`);
    const slResult = await exchange.order({
      orders: [{
        a: assetId,
        b: !isBuy,
        r: true,
        p: args.stopLoss,
        s: sz,
        t: {
          trigger: {
            triggerPx: args.stopLoss,
            isMarket: true,
            tpsl: 'sl',
          },
        },
      }],
      grouping: 'na',
    });
    console.log('Stop loss set:', JSON.stringify(slResult, null, 2));
  }
}

async function closePosition(
  exchange: ExchangeClient,
  info: InfoClient,
  args: TradeArgs,
  masterAddress: string,
) {
  if (!args.pair) { console.error('--pair is required'); process.exit(1); }

  const { index: assetId } = await getAssetIndex(info, args.pair);

  // Get current position to determine size and side
  const state = await info.clearinghouseState({ user: masterAddress as `0x${string}` });
  const position = state.assetPositions.find(
    (p: any) => p.position.coin.toUpperCase() === args.pair!.toUpperCase(),
  );

  if (!position) {
    console.error(`No open position for ${args.pair}`);
    process.exit(1);
  }

  const posSize = parseFloat(position.position.szi);
  const isBuy = posSize < 0; // Close short = buy, close long = sell
  const sz = Math.abs(posSize).toString();

  // Market close with 1% slippage
  const mids = await info.allMids();
  const midPrice = parseFloat(mids[args.pair!.toUpperCase()]);
  const slippage = isBuy ? 1.01 : 0.99;
  const orderPrice = formatPrice(midPrice * slippage);

  console.log(`Closing ${args.pair} position — size: ${sz}, price: ${orderPrice}`);

  const result = await exchange.order({
    orders: [{
      a: assetId,
      b: isBuy,
      r: true,
      p: orderPrice,
      s: sz,
      t: { limit: { tif: 'Ioc' } },
    }],
    grouping: 'na',
  });

  console.log(JSON.stringify(result, null, 2));
}

async function modifyPosition(
  exchange: ExchangeClient,
  info: InfoClient,
  args: TradeArgs,
  masterAddress: string,
) {
  if (!args.pair) { console.error('--pair is required'); process.exit(1); }
  if (!args.leverage && !args.stopLoss && !args.takeProfit) {
    console.error('At least one of --leverage, --sl, or --tp is required');
    process.exit(1);
  }

  const { index: assetId } = await getAssetIndex(info, args.pair);

  // Get current position
  const state = await info.clearinghouseState({ user: masterAddress as `0x${string}` });
  const position = state.assetPositions.find(
    (p: any) => p.position.coin.toUpperCase() === args.pair!.toUpperCase(),
  );

  if (!position) {
    console.error(`No open position for ${args.pair}`);
    process.exit(1);
  }

  const posSize = parseFloat(position.position.szi);
  const isBuy = posSize > 0; // Long position
  const sz = Math.abs(posSize).toString();

  if (args.leverage) {
    await exchange.updateLeverage({
      asset: assetId,
      isCross: true,
      leverage: args.leverage,
    });
    console.log(`Leverage updated to ${args.leverage}x`);
  }

  // Cancel existing TP/SL orders before placing new ones
  const openOrders = await info.openOrders({ user: masterAddress as `0x${string}` });
  const tpslOrders = openOrders.filter(
    (o: any) => o.coin?.toUpperCase() === args.pair!.toUpperCase() && o.orderType?.includes('trigger'),
  );
  if (tpslOrders.length > 0) {
    for (const order of tpslOrders) {
      try {
        await exchange.cancel({ cancels: [{ a: assetId, o: order.oid }] });
      } catch {
        // Ignore cancel failures for already-filled orders
      }
    }
  }

  if (args.takeProfit) {
    console.log(`Setting take profit at ${args.takeProfit}...`);
    const tpResult = await exchange.order({
      orders: [{
        a: assetId,
        b: !isBuy,
        r: true,
        p: args.takeProfit,
        s: sz,
        t: {
          trigger: {
            triggerPx: args.takeProfit,
            isMarket: true,
            tpsl: 'tp',
          },
        },
      }],
      grouping: 'na',
    });
    console.log('Take profit set:', JSON.stringify(tpResult, null, 2));
  }

  if (args.stopLoss) {
    console.log(`Setting stop loss at ${args.stopLoss}...`);
    const slResult = await exchange.order({
      orders: [{
        a: assetId,
        b: !isBuy,
        r: true,
        p: args.stopLoss,
        s: sz,
        t: {
          trigger: {
            triggerPx: args.stopLoss,
            isMarket: true,
            tpsl: 'sl',
          },
        },
      }],
      grouping: 'na',
    });
    console.log('Stop loss set:', JSON.stringify(slResult, null, 2));
  }
}

async function showPositions(info: InfoClient, masterAddress: string) {
  const state = await info.clearinghouseState({ user: masterAddress as `0x${string}` });
  const positions = state.assetPositions.filter(
    (p: any) => parseFloat(p.position.szi) !== 0,
  );

  if (positions.length === 0) {
    console.log('No open positions');
    return;
  }

  console.log(JSON.stringify(positions, null, 2));
}

async function showBalance(info: InfoClient, masterAddress: string) {
  const user = masterAddress as `0x${string}`;

  // Spot balance (primary balance in unified account mode)
  const spotState = await info.spotClearinghouseState({ user });
  const spotBalances = spotState.balances.filter(
    (b: any) => parseFloat(b.hold) !== 0 || parseFloat(b.total) !== 0,
  );

  // Perp balance (margin summary)
  const perpState = await info.clearinghouseState({ user });

  console.log(
    JSON.stringify(
      {
        spot: {
          balances: spotBalances,
        },
        perp: {
          accountValue: perpState.marginSummary.accountValue,
          totalMarginUsed: perpState.marginSummary.totalMarginUsed,
          withdrawable: perpState.withdrawable,
          crossMaintenanceMarginUsed: perpState.crossMaintenanceMarginUsed,
        },
      },
      null,
      2,
    ),
  );
}

async function showTickers(info: InfoClient) {
  const meta = await info.meta();
  const mids = await info.allMids();

  const tickers = meta.universe.map((asset: any, i: number) => ({
    symbol: asset.name,
    midPrice: mids[asset.name] ?? 'N/A',
    maxLeverage: asset.maxLeverage,
    szDecimals: asset.szDecimals,
  }));

  console.log(JSON.stringify(tickers, null, 2));
}

// ---- Signing (ACP CLI, master wallet — no API wallet) ----

// EIP-712 primaryType is the root struct: the one not referenced as a field
// type by any other struct. The SDK omits it when calling an ethers-style
// signer, but acp-cli needs it in the typed-data payload.
function derivePrimaryType(
  types: Record<string, Array<{ name: string; type: string }>>,
): string {
  const referenced = new Set<string>();
  for (const fields of Object.values(types)) {
    for (const f of fields) {
      const base = f.type.replace(/(\[\d*\])+$/, '');
      if (types[base]) referenced.add(base);
    }
  }
  return Object.keys(types).find((t) => !referenced.has(t)) ?? Object.keys(types)[0];
}

// Resolve the master (ACP agent) wallet address. This is the account that
// signs orders and whose positions/balances we read.
function getMasterAddress(): string {
  const env = process.env.HL_MASTER_ADDRESS;
  if (env) return env;

  const acp = getAcpBin();
  try {
    const result = execSync(`${acp} agent whoami --json`, {
      encoding: 'utf-8',
      cwd: ACP_DIR,
      stdio: ['pipe', 'pipe', 'pipe'],
    });
    const parsed = JSON.parse(result);
    const addr = parsed.walletAddress ?? parsed.data?.walletAddress ?? parsed.address;
    if (!addr) throw new Error('no address in acp whoami output');
    return addr;
  } catch {
    console.error('HL_MASTER_ADDRESS not set and could not auto-detect via acp-cli.');
    console.error('Set HL_MASTER_ADDRESS or run: acp configure && acp agent create');
    process.exit(1);
  }
}

// An ethers-v6-shaped signer the Hyperliquid SDK can use. Instead of holding a
// private key, every EIP-712 signature is delegated to the ACP CLI, which signs
// with the agent's managed (master) wallet — same mechanism as withdraw.ts.
// The SDK detects this as an ethers v6 signer (signTypedData arity 3 + getAddress).
function makeAcpWallet(masterAddress: string) {
  const acp = getAcpBin();
  return {
    async getAddress(): Promise<string> {
      return masterAddress;
    },
    async signTypedData(domain: any, types: any, message: any): Promise<string> {
      const typedData = {
        domain,
        types,
        primaryType: derivePrimaryType(types),
        message,
      };
      try {
        const result = execSync(
          `${acp} wallet sign-typed-data --data '${JSON.stringify(typedData)}' --json`,
          { encoding: 'utf-8', cwd: ACP_DIR, stdio: ['pipe', 'pipe', 'pipe'] },
        );
        const parsed = JSON.parse(result);
        return parsed.signature ?? parsed.data?.signature ?? result.trim();
      } catch (err: any) {
        console.error('Failed to sign with ACP CLI. Make sure acp-cli is configured:');
        console.error('  acp configure && acp agent add-signer');
        console.error(err.stderr || err.message);
        process.exit(1);
      }
    },
  };
}

// ---- Main ----

async function main() {
  const args = parseArgs();

  const transport = new HttpTransport({ url: HL_API_URL });
  const info = new InfoClient({ transport });

  // Read-only, no wallet/acp-cli required.
  if (args.command === 'tickers') {
    await showTickers(info);
    return;
  }

  const masterAddress = getMasterAddress();

  switch (args.command) {
    case 'positions':
      await showPositions(info, masterAddress);
      break;
    case 'balance':
      await showBalance(info, masterAddress);
      break;
    case 'open':
    case 'close':
    case 'modify': {
      const wallet = makeAcpWallet(masterAddress);
      const exchange = new ExchangeClient({ wallet: wallet as any, transport });
      if (args.command === 'open') await openPosition(exchange, info, args, masterAddress);
      else if (args.command === 'close') await closePosition(exchange, info, args, masterAddress);
      else await modifyPosition(exchange, info, args, masterAddress);
      break;
    }
    default:
      console.error(`Unknown command: ${args.command}`);
      printUsage();
  }
}

main().catch((err) => {
  console.error('Error:', err.message);
  process.exit(1);
});

import 'dotenv/config';
import { execSync } from 'child_process';
import { existsSync } from 'fs';
import { resolve, dirname } from 'path';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

const ACP_DIR = process.env.ACP_CLI_DIR || resolve(__dirname, '..', '..', 'acp-cli');

function getAcpBin(): string {
  const bin = resolve(ACP_DIR, 'bin', 'acp.ts');
  if (!existsSync(bin)) {
    console.error(`acp-cli not found at ${bin}`);
    console.error('Set ACP_CLI_DIR or clone acp-cli as a sibling directory.');
    process.exit(1);
  }
  return `npx tsx ${bin}`;
}

const ACP = getAcpBin();

const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
const CHAIN_ID = 42161;
const HL_API_URL = 'https://api.hyperliquid.xyz/exchange';

const Withdraw3Types = {
  'HyperliquidTransaction:Withdraw': [
    { name: 'hyperliquidChain', type: 'string' },
    { name: 'destination', type: 'string' },
    { name: 'amount', type: 'string' },
    { name: 'time', type: 'uint64' },
  ],
} as const;

function parseSignature(sig: string): { r: string; s: string; v: number } {
  const raw = sig.startsWith('0x') ? sig.slice(2) : sig;
  return {
    r: `0x${raw.slice(0, 64)}`,
    s: `0x${raw.slice(64, 128)}`,
    v: parseInt(raw.slice(128, 130), 16),
  };
}

function getWalletAddress(): string {
  try {
    const result = execSync(`${ACP} agent whoami --json`, { encoding: 'utf-8', cwd: ACP_DIR, stdio: ['pipe', 'pipe', 'pipe'] });
    const parsed = JSON.parse(result);
    return parsed.walletAddress ?? parsed.data?.walletAddress ?? parsed.address;
  } catch (err: any) {
    console.error('Failed to get wallet address. Make sure acp-cli is configured:');
    console.error('  acp configure && acp agent create');
    process.exit(1);
  }
}

async function main() {
  const args = process.argv.slice(2);

  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
    console.log('Usage: npx tsx scripts/withdraw.ts --amount <usdc> [--destination <address>]');
    console.log('');
    console.log('Withdraw USDC from Hyperliquid to Arbitrum.');
    console.log('Builds the withdrawal transaction and signs it via ACP CLI (master wallet).');
    console.log('');
    console.log('Options:');
    console.log('  --amount <usdc>          USDC amount to withdraw (required)');
    console.log('  --destination <address>  Arbitrum address to receive USDC (default: your agent wallet)');
    process.exit(args.length === 0 ? 1 : 0);
  }

  const amountIdx = args.indexOf('--amount');
  if (amountIdx === -1 || !args[amountIdx + 1]) {
    console.error('--amount is required');
    process.exit(1);
  }
  const amount = args[amountIdx + 1];

  const walletAddress = getWalletAddress();

  const destIdx = args.indexOf('--destination');
  const destination = destIdx !== -1 && args[destIdx + 1] ? args[destIdx + 1] : walletAddress;

  const nonce = Date.now();

  const action = {
    type: 'withdraw3' as const,
    signatureChainId: `0x${CHAIN_ID.toString(16)}`,
    hyperliquidChain: 'Mainnet',
    destination,
    amount,
    time: nonce,
  };

  const primaryType = Object.keys(Withdraw3Types)[0];
  const typedData = {
    domain: {
      name: 'HyperliquidSignTransaction',
      version: '1',
      chainId: CHAIN_ID,
      verifyingContract: ZERO_ADDRESS,
    },
    types: Withdraw3Types,
    primaryType,
    message: {
      hyperliquidChain: 'Mainnet',
      destination,
      amount,
      time: nonce,
    },
  };

  console.log(`Withdrawing ${amount} USDC to ${destination}`);
  console.log('\nSigning withdrawal transaction...');

  let signature: string;
  try {
    const typedDataJson = JSON.stringify(typedData);
    const result = execSync(`${ACP} wallet sign-typed-data --data '${typedDataJson}' --json`, {
      encoding: 'utf-8',
      cwd: ACP_DIR,
      stdio: ['pipe', 'pipe', 'pipe'],
    });
    const parsed = JSON.parse(result);
    signature = parsed.signature ?? parsed.data?.signature ?? result.trim();
  } catch (err: any) {
    console.error('Failed to sign with ACP CLI. Make sure acp-cli is configured:');
    console.error('  acp configure && acp agent add-signer');
    console.error('');
    console.error(err.stderr || err.message);
    process.exit(1);
  }

  const { r, s, v } = parseSignature(signature);

  console.log('Broadcasting to Hyperliquid...');
  const response = await fetch(HL_API_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ action, signature: { r, s, v }, nonce }),
  });

  const result = await response.json();

  if (result.status === 'ok') {
    console.log('\nWithdrawal submitted successfully!');
    console.log(`  Amount: ${amount} USDC`);
    console.log(`  Destination: ${destination}`);
    console.log('  Note: Withdrawal may take a few minutes to process on Arbitrum.');
  } else {
    console.error('\nWithdrawal failed:');
    console.error(JSON.stringify(result, null, 2));
    process.exit(1);
  }
}

main().catch(console.error);