Crypto Agent Trading

{
  "slug": "crypto-agent-trading",
  "version": "1.0.0",
  "publishedAt": 1772262436
}

import { apiGet, apiPost, assertOk } from "./lib/api.js";
import { ErrorCode, fail, run, success } from "./lib/output.js";

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function filterFiat(balances: any[]): any[] {
    return balances.filter((b: any) => parseFloat(b.amount?.amount ?? "0") > 0);
}

function filterCrypto(wallets: any[]): any[] {
    return wallets.filter((w: any) => {
        const amt = w.available?.amount ?? w.balance?.amount ?? "0";
        return parseFloat(amt) > 0;
    });
}

// ---------------------------------------------------------------------------
// Commands
// ---------------------------------------------------------------------------

async function balances(scope: string) {
    const validScopes = ["fiat", "crypto", "all"];
    if (!validScopes.includes(scope)) {
        fail(ErrorCode.INVALID_ARGS, `Invalid scope "${scope}". Use: fiat | crypto | all`);
    }

    const includeFiat = scope !== "crypto";
    const includeCrypto = scope !== "fiat";
    const result: Record<string, any> = {};

    if (includeFiat) {
        const res = await apiGet("/v1/fiat-account");
        assertOk(res, "Fiat balance fetch");
        result.fiat = filterFiat(res.data.account.balances);
    }

    if (includeCrypto) {
        const res = await apiGet("/v1/crypto-account");
        assertOk(res, "Crypto balance fetch");
        result.crypto = filterCrypto(res.data.account.wallets);
    }

    success(result);
}

async function balance(symbol: string) {
    if (!symbol) {
        fail(ErrorCode.INVALID_ARGS, "Token symbol required. Example: npx tsx scripts/account.ts balance BTC");
    }

    const upper = symbol.toUpperCase();
    const res = await apiGet("/v1/crypto-account");
    assertOk(res, "Crypto balance fetch");

    const wallet = (res.data.account.wallets as any[]).find(
        (w: any) => w.currency.toUpperCase() === upper,
    );

    success({
        currency: upper,
        available: wallet?.available?.amount ?? "0",
        balance: wallet?.balance?.amount ?? "0",
    });
}

async function tradingLimit() {
    const res = await apiGet("/v1/api-keys/current");
    assertOk(res, "Trading limit fetch");

    const k = res.data.api_key;
    const limit = parseFloat(k.weekly_trading_limit_in_usd);
    const remaining = parseFloat(k.remaining_weekly_trading_limit_in_usd);

    success({ used: limit - remaining, limit, remaining, currency: "USD" });
}

async function resolveSource(tradeType: string) {
    const validTypes = ["purchase", "sale", "exchange"];
    if (!validTypes.includes(tradeType)) {
        fail(ErrorCode.INVALID_ARGS, `Invalid trade type "${tradeType}". Use: purchase | sale | exchange`);
    }

    const walletType = tradeType === "purchase" ? "fiat" : "crypto";

    if (walletType === "fiat") {
        const res = await apiGet("/v1/fiat-account");
        assertOk(res, "Fiat balance fetch");
        emitResolveResult(filterFiat(res.data.account.balances), walletType);
    } else {
        const res = await apiGet("/v1/crypto-account");
        assertOk(res, "Crypto balance fetch");
        emitResolveResult(filterCrypto(res.data.account.wallets), walletType);
    }
}

function emitResolveResult(funded: any[], walletType: string): never {
    if (funded.length === 1) {
        success({ status: "SELECTED", currency: funded[0].currency, walletType });
    } else if (funded.length > 1) {
        success({ status: "AMBIGUOUS", options: funded.map((w: any) => w.currency), walletType });
    } else {
        success({ status: "EMPTY", walletType });
    }
}

async function revokeKey() {
    const res = await apiPost("/v1/api-keys/self-revoke", {});

    const errorCode = res.data?.error || res.data?.code;

    if (errorCode === "api_key_not_found") {
        fail(ErrorCode.API_KEY_NOT_FOUND, "API key not found — it may have already been revoked or does not exist.");
    }

    if (errorCode === "key_not_active") {
        fail(ErrorCode.API_KEY_NOT_FOUND, "API key is not active — it has been revoked or expired.");
    }

    if (res.status !== 200 || res.data?.ok === false) {
        const apiMsg = res.data?.error_message || res.data?.message;
        const detail = apiMsg && errorCode ? `${errorCode}: ${apiMsg}` : errorCode || apiMsg || `HTTP ${res.status}`;
        fail(ErrorCode.API_ERROR, `Kill switch request failed: ${detail}`);
    }

    success({ revoked: true });
}

// ---------------------------------------------------------------------------
// CLI router
// ---------------------------------------------------------------------------

const USAGE = `Usage: npx tsx scripts/account.ts <command> [args]

Commands:
  balances [fiat|crypto|all]       Filtered non-zero balances (default: all)
  balance <SYMBOL>                 Single token balance lookup
  trading-limit                    Weekly trading limit info
  resolve-source <type>            Find funded wallets (purchase|sale|exchange)
  revoke-key                       Revoke API key (kill switch)`;

run(async () => {
    const [command, arg] = process.argv.slice(2);

    switch (command) {
        case "balances":
            return balances(arg || "all");
        case "balance":
            return balance(arg);
        case "trading-limit":
            return tradingLimit();
        case "resolve-source":
            return resolveSource(arg);
        case "revoke-key":
            return revokeKey();
        default:
            fail(ErrorCode.INVALID_ARGS, command ? `Unknown command "${command}".\n\n${USAGE}` : USAGE);
    }
});

import { apiGet, assertOk } from "./lib/api.js";
import { ErrorCode, fail, run, success } from "./lib/output.js";

// ---------------------------------------------------------------------------
// Commands
// ---------------------------------------------------------------------------

async function search(paramsJson: string) {
    if (!paramsJson) {
        fail(
            ErrorCode.INVALID_ARGS,
            `JSON params required. Example: npx tsx scripts/coins.ts search '{"keyword":"BTC","sort_by":"rank","sort_direction":"asc","native_currency":"USD","page_size":10}'`,
        );
    }

    let params: any;
    try {
        params = JSON.parse(paramsJson);
    } catch {
        fail(ErrorCode.INVALID_ARGS, `Invalid JSON: ${paramsJson}`);
    }

    const qs = new URLSearchParams();
    for (const [key, val] of Object.entries(params)) {
        if (val !== undefined && val !== null) qs.set(key, String(val));
    }

    const path = `/v1/crypto/coins?${qs.toString()}`;
    const res = await apiGet(path);
    assertOk(res, "Coin search");

    success({
        coins: res.data.coins,
        pagination: res.data.pagination,
    });
}

// ---------------------------------------------------------------------------
// CLI router
// ---------------------------------------------------------------------------

const USAGE = `Usage: npx tsx scripts/coins.ts <command> [args]

Commands:
  search '<json>'    Search coins by keyword, sort, pagination`;

run(async () => {
    const [command, arg] = process.argv.slice(2);

    switch (command) {
        case "search":
            return search(arg);
        default:
            fail(ErrorCode.INVALID_ARGS, command ? `Unknown command "${command}".\n\n${USAGE}` : USAGE);
    }
});

import crypto from "node:crypto";
import os from "node:os";
import { ErrorCode, fail } from "./output.js";

export const BASE_URL = "https://wapi.crypto.com";

function getCredentials(): { apiKey: string; apiSecret: string } {
    const apiKey = process.env.CDC_API_KEY;
    const apiSecret = process.env.CDC_API_SECRET;
    if (!apiKey || !apiSecret) {
        fail(
            ErrorCode.MISSING_ENV,
            `CDC_API_KEY and/or CDC_API_SECRET not set. Run:\n  export CDC_API_KEY="your-key"\n  export CDC_API_SECRET="your-secret"`,
        );
    }
    return { apiKey, apiSecret };
}

function getSignedHeaders(method: string, path: string, body?: unknown): Record<string, string> {
    const { apiKey, apiSecret } = getCredentials();
    const timestamp = Date.now().toString();
    const bodyStr = body ? JSON.stringify(body) : "";
    const signPayload = timestamp + method.toUpperCase() + path + bodyStr;
    const signature = crypto
        .createHmac("sha256", apiSecret)
        .update(signPayload)
        .digest("base64");
    const userAgent = `Node/${process.version} ${os.platform()}/${os.release()}-cdc-clawbot/1.0`;

    return {
        "Content-Type": "application/json",
        "User-Agent": userAgent,
        "Cdc-Api-Key": apiKey,
        "Cdc-Api-Timestamp": timestamp,
        "Cdc-Api-Signature": signature,
    };
}

interface ApiResponse {
    status: number;
    data: any;
}

async function request(method: string, path: string, body?: unknown): Promise<ApiResponse> {
    const headers = getSignedHeaders(method, path, body);
    const url = `${BASE_URL}${path}`;

    const res = await fetch(url, {
        method,
        headers,
        body: body ? JSON.stringify(body) : undefined,
    });

    let data: any;
    try {
        data = await res.json();
    } catch {
        fail(ErrorCode.API_ERROR, `Non-JSON response from ${method} ${path} (HTTP ${res.status})`);
    }

    return { status: res.status, data };
}

export async function apiGet(path: string): Promise<ApiResponse> {
    return request("GET", path);
}

export async function apiPost(path: string, body?: unknown): Promise<ApiResponse> {
    return request("POST", path, body);
}

export function assertOk(res: ApiResponse, context: string): void {
    if (res.status === 429) {
        fail(
            ErrorCode.RATE_LIMITED,
            `${context}: Rate limit exceeded. Wait 60 seconds before retrying.`,
        );
    }
    if (res.status !== 200 || res.data?.ok !== true) {
        const apiError = res.data?.error || res.data?.code;
        const apiMsg = res.data?.error_message || res.data?.message;
        const detail = apiMsg && apiError ? `${apiError}: ${apiMsg}` : apiError || apiMsg || `HTTP ${res.status}`;
        fail(ErrorCode.API_ERROR, `${context}: ${detail}`);
    }
}

export const ErrorCode = {
    MISSING_ENV: "MISSING_ENV",
    API_ERROR: "API_ERROR",
    INVALID_ARGS: "INVALID_ARGS",
    QUOTATION_FAILED: "QUOTATION_FAILED",
    EXECUTION_FAILED: "EXECUTION_FAILED",
    API_KEY_NOT_FOUND: "API_KEY_NOT_FOUND",
    RATE_LIMITED: "RATE_LIMITED",
    UNKNOWN: "UNKNOWN",
} as const;

export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];

interface SuccessOutput {
    ok: true;
    data: unknown;
}

interface ErrorOutput {
    ok: false;
    error: string;
    error_message: string;
}

export function success(data: unknown): never {
    const out: SuccessOutput = { ok: true, data };
    console.log(JSON.stringify(out, null, 2));
    process.exit(0);
}

export function fail(code: ErrorCode, message: string): never {
    const out: ErrorOutput = { ok: false, error: code, error_message: message };
    console.log(JSON.stringify(out, null, 2));
    process.exit(1);
}

export function run(fn: () => Promise<void>): void {
    fn().catch((err: unknown) => {
        const message = err instanceof Error ? err.message : String(err);
        fail(ErrorCode.UNKNOWN, message);
    });
}

import { apiGet, apiPost, assertOk } from "./lib/api.js";
import { ErrorCode, fail, run, success } from "./lib/output.js";

// ---------------------------------------------------------------------------
// Quotation body builders
// ---------------------------------------------------------------------------

const QUOTE_PATHS: Record<string, string> = {
    purchase: "/v1/crypto-purchase/quotations",
    sale: "/v1/crypto-sales/quotations",
    exchange: "/v1/crypto-exchange/quotations",
};

const ORDER_PATHS: Record<string, string> = {
    purchase: "/v1/crypto-purchase/orders",
    sale: "/v1/crypto-sales/orders",
    exchange: "/v1/crypto-exchange/orders",
};

function buildQuotationBody(type: string, params: any): Record<string, any> {
    switch (type) {
        case "purchase":
            return {
                from_currency: params.from_currency,
                to_currency: params.to_currency,
                ...(params.from_amount
                    ? { from_amount: params.from_amount }
                    : { to_amount: params.to_amount }),
            };
        case "sale":
            return {
                from_currency: params.from_currency,
                from_amount: params.from_amount,
                to_currency: params.to_currency,
                fixed_side: params.fixed_side || "from",
            };
        case "exchange":
            return {
                from: params.from_currency,
                to: params.to_currency,
                from_amount: params.from_amount,
                side: params.side || "buy",
            };
        default:
            fail(ErrorCode.INVALID_ARGS, `Unknown trade type: ${type}`);
    }
}

// ---------------------------------------------------------------------------
// Commands
// ---------------------------------------------------------------------------

async function quote(type: string, paramsJson: string) {
    if (!QUOTE_PATHS[type]) {
        fail(ErrorCode.INVALID_ARGS, `Invalid trade type "${type}". Use: purchase | sale | exchange`);
    }
    if (!paramsJson) {
        fail(ErrorCode.INVALID_ARGS, `JSON params required. Example: npx tsx scripts/trade.ts quote purchase '{"from_currency":"USD","to_currency":"BTC","from_amount":"100"}'`);
    }

    let params: any;
    try {
        params = JSON.parse(paramsJson);
    } catch {
        fail(ErrorCode.INVALID_ARGS, `Invalid JSON: ${paramsJson}`);
    }

    const body = buildQuotationBody(type, params);
    const res = await apiPost(QUOTE_PATHS[type], body);

    if (res.status !== 200 || res.data?.ok !== true) {
        const apiError = res.data?.error;
        const apiMsg = res.data?.error_message;
        const msg = apiMsg && apiError ? `${apiError}: ${apiMsg}` : apiError || apiMsg || "Quotation request rejected.";
        fail(ErrorCode.QUOTATION_FAILED, msg);
    }

    success(res.data.quotation);
}

async function confirm(type: string, quotationId: string) {
    if (!ORDER_PATHS[type]) {
        fail(ErrorCode.INVALID_ARGS, `Invalid trade type "${type}". Use: purchase | sale | exchange`);
    }
    if (!quotationId) {
        fail(ErrorCode.INVALID_ARGS, "Quotation ID required. Example: npx tsx scripts/trade.ts confirm purchase <quotation-id>");
    }

    const body: Record<string, string> =
        type === "exchange"
            ? { quotation_id: quotationId, side: "buy" }
            : { quotation_id: quotationId };

    const res = await apiPost(ORDER_PATHS[type], body);

    if (res.status !== 200 || res.data?.ok !== true) {
        const apiError = res.data?.error;
        const apiMsg = res.data?.error_message;
        const msg = apiMsg && apiError ? `${apiError}: ${apiMsg}` : apiError || apiMsg || "Order confirmation failed.";
        fail(ErrorCode.EXECUTION_FAILED, msg);
    }

    success(res.data.transaction);
}

async function history() {
    const res = await apiGet("/v1/transactions");
    assertOk(res, "Transaction history fetch");

    const txns = (res.data.transactions ?? []).slice(0, 5);
    success(txns);
}

// ---------------------------------------------------------------------------
// CLI router
// ---------------------------------------------------------------------------

const USAGE = `Usage: npx tsx scripts/trade.ts <command> [args]

Commands:
  quote <type> '<json>'            Get quotation (purchase|sale|exchange)
  confirm <type> <quotation-id>    Confirm order
  history                          Last 5 transactions`;

run(async () => {
    const [command, arg1, arg2] = process.argv.slice(2);

    switch (command) {
        case "quote":
            return quote(arg1, arg2);
        case "confirm":
            return confirm(arg1, arg2);
        case "history":
            return history();
        default:
            fail(ErrorCode.INVALID_ARGS, command ? `Unknown command "${command}".\n\n${USAGE}` : USAGE);
    }
});