Crypto Com App

{
  "slug": "crypto-com-app",
  "version": "1.0.2",
  "publishedAt": 1774857600
}

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;
    });
}

function parsePortfolioProducts(res: any): any[] | null {
    if (res.data?.ok !== true) return null;
    return (res.data.products as any[] ?? []).filter(
        (p: any) => parseFloat(p.price_native?.amount ?? "0") > 0,
    );
}

function parseCurrencyAllocation(res: any): Record<string, string> | null {
    if (res.data?.ok !== true) return null;
    const allocation: Record<string, string> = {};
    for (const [key, val] of Object.entries(res.data)) {
        if (key === "ok") continue;
        const entry = val as any;
        if (entry?.amount && parseFloat(entry.amount) > 0) {
            allocation[key] = entry.amount;
        }
    }
    return Object.keys(allocation).length > 0 ? allocation : null;
}

// ---------------------------------------------------------------------------
// 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 [cryptoRes, portfolioRes] = await Promise.all([
            apiGet("/v1/crypto-account"),
            apiGet("/v1/portfolio"),
        ]);
        assertOk(cryptoRes, "Crypto balance fetch");
        result.crypto = {
            note: "available for trading",
            wallets: filterCrypto(cryptoRes.data.account.wallets),
        };
        const products = parsePortfolioProducts(portfolioRes);
        if (products) {
            result.portfolio_allocation = products;
        }
    }

    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 [cryptoRes, allocationRes] = await Promise.all([
        apiGet("/v1/crypto-account"),
        apiGet(`/v1/portfolio/currency_allocation?currency=${upper}`),
    ]);
    assertOk(cryptoRes, "Crypto balance fetch");

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

    const result: Record<string, any> = {
        currency: upper,
        available: wallet?.available?.amount ?? "0",
        available_note: "available for trading",
        balance: wallet?.balance?.amount ?? "0",
    };

    const allocation = parseCurrencyAllocation(allocationRes);
    if (allocation) {
        result.product_allocation = allocation;
    }

    success(result);
}

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 readline from "node:readline";
import { apiGet, apiPost, assertOk } from "./lib/api.js";
import { ErrorCode, fail, run, success } from "./lib/output.js";

// ---------------------------------------------------------------------------
// Helper: TOTP prompt
// ---------------------------------------------------------------------------

async function promptTotp(): Promise<string> {
    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
    return new Promise((resolve) => {
        rl.question("TOTP code required. Enter your 6-digit authenticator code: ", (answer) => {
            rl.close();
            resolve(answer.trim());
        });
    });
}

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

async function discover() {
    const accountRes = await apiGet("/v1/fiat-account");
    assertOk(accountRes, "Fiat account fetch");

    const balances: any[] = accountRes.data.account?.balances ?? [];
    if (balances.length === 0) {
        success({ currencies: [] });
        return;
    }

    const currencies = [];
    for (const bal of balances) {
        const ccy = bal.currency;
        const balance = bal.amount?.amount ?? "0";

        const netRes = await apiGet(`/v1/fiat/payment-networks?currency=${encodeURIComponent(ccy)}`);
        if (netRes.status !== 200 || netRes.data.ok !== true) {
            currencies.push({ currency: ccy, balance, deposit: [], withdrawal: [] });
            continue;
        }

        const networks: any[] = netRes.data.available_payment_networks ?? [];
        const net = networks.find((n: any) => n.currency === ccy);
        if (!net) {
            currencies.push({ currency: ccy, balance, deposit: [], withdrawal: [] });
            continue;
        }

        currencies.push({
            currency: ccy,
            balance,
            deposit: net.deposit_push_payment_networks ?? [],
            withdrawal: net.withdrawal_payment_networks ?? [],
        });
    }

    success({ currencies });
}

async function paymentNetworks(currency: string) {
    if (!currency) {
        fail(ErrorCode.INVALID_ARGS, "Currency required. Example: npx tsx scripts/fiat.ts payment-networks USD");
    }

    const res = await apiGet(`/v1/fiat/payment-networks?currency=${encodeURIComponent(currency)}`);
    assertOk(res, `Payment networks fetch for ${currency}`);

    success(res.data.available_payment_networks);
}

async function depositMethods(currency: string, depositMethod: string) {
    if (!currency) {
        fail(ErrorCode.INVALID_ARGS, "Currency required. Example: npx tsx scripts/fiat.ts deposit-methods USD sepa");
    }
    if (!depositMethod) {
        fail(ErrorCode.INVALID_ARGS, "Deposit method required. Example: npx tsx scripts/fiat.ts deposit-methods USD sepa");
    }

    const res = await apiGet(
        `/v1/fiat/deposit-methods?currency=${encodeURIComponent(currency)}&deposit_method=${encodeURIComponent(depositMethod)}`,
    );
    assertOk(res, `Deposit methods fetch for ${currency} ${depositMethod}`);

    success(res.data.deposit_methods);
}

async function emailDepositInfo(currency: string, vibanType: string) {
    if (!currency) {
        fail(ErrorCode.INVALID_ARGS, "Currency required. Example: npx tsx scripts/fiat.ts email-deposit-info USD iban");
    }
    if (!vibanType) {
        fail(ErrorCode.INVALID_ARGS, "VIBAN type required. Example: npx tsx scripts/fiat.ts email-deposit-info USD iban");
    }

    const res = await apiPost("/v1/fiat/deposit-info/email", {
        currency,
        viban_type: vibanType,
    });
    assertOk(res, `Email deposit info for ${currency} ${vibanType}`);

    success(res.data.bank_info_email);
}

async function withdrawalDetails(currency: string, vibanType: string) {
    if (!currency) {
        fail(ErrorCode.INVALID_ARGS, "Currency required. Example: npx tsx scripts/fiat.ts withdrawal-details USD iban");
    }
    if (!vibanType) {
        fail(ErrorCode.INVALID_ARGS, "VIBAN type required. Example: npx tsx scripts/fiat.ts withdrawal-details USD iban");
    }

    const res = await apiGet(
        `/v1/fiat/withdrawal-details?currency=${encodeURIComponent(currency)}&viban_type=${encodeURIComponent(vibanType)}`,
    );
    assertOk(res, `Withdrawal details fetch for ${currency} ${vibanType}`);

    success(res.data.details);
}

async function createWithdrawalOrder(paramsJson: string) {
    if (!paramsJson) {
        fail(
            ErrorCode.INVALID_ARGS,
            `JSON params required. Example: npx tsx scripts/fiat.ts create-withdrawal-order '{"currency":"USD","amount":"100","viban_type":"iban"}'`,
        );
    }

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

    if (!params.currency || !params.amount || !params.viban_type) {
        fail(ErrorCode.INVALID_ARGS, "Required fields: currency, amount, viban_type");
    }

    const res = await apiPost("/v1/fiat/withdrawal-orders", params);
    assertOk(res, "Withdrawal order creation");

    success(res.data.viban_withdrawal_order);
}

async function createWithdrawal(orderId: string) {
    if (!orderId) {
        fail(ErrorCode.INVALID_ARGS, "Order ID required. Example: npx tsx scripts/fiat.ts create-withdrawal <order-id>");
    }

    let res = await apiPost("/v1/fiat/withdrawals", { order_id: orderId });

    // Check for TOTP requirement
    if (res.data?.error === "totp_required") {
        const otp = await promptTotp();
        res = await apiPost("/v1/fiat/withdrawals", { order_id: orderId, otp });
    }

    assertOk(res, "Withdrawal creation");

    success(res.data.viban_withdrawal);
}

async function bankAccounts(currency?: string) {
    const path = currency ? `/v1/fiat/bank-accounts?currency=${encodeURIComponent(currency)}` : "/v1/fiat/bank-accounts";
    const res = await apiGet(path);
    assertOk(res, currency ? `Bank accounts fetch for ${currency}` : "Bank accounts fetch");

    success(res.data.bank_accounts);
}

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

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

Commands:
  discover                                       Cash overview (balances + payment networks)
  payment-networks <currency>                    Available deposit/withdrawal networks
  deposit-methods <currency> <deposit_method>    Bank details for a deposit method
  email-deposit-info <currency> <viban_type>     Email deposit instructions to user
  withdrawal-details <currency> <viban_type>     Withdrawal quotas, fees, minimums
  create-withdrawal-order '<json>'               Create withdrawal order
  create-withdrawal <order_id>                   Execute withdrawal (may prompt for TOTP)
  bank-accounts [currency]                       List linked bank accounts`;

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

    switch (command) {
        case "discover":
            return discover();
        case "payment-networks":
            return paymentNetworks(arg1);
        case "deposit-methods":
            return depositMethods(arg1, arg2);
        case "email-deposit-info":
            return emailDepositInfo(arg1, arg2);
        case "withdrawal-details":
            return withdrawalDetails(arg1, arg2);
        case "create-withdrawal-order":
            return createWithdrawalOrder(arg1);
        case "create-withdrawal":
            return createWithdrawal(arg1);
        case "bank-accounts":
            return bankAccounts(arg1);
        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`;

    const headers: Record<string, string> = {
        "User-Agent": userAgent,
        "Cdc-Api-Key": apiKey,
        "Cdc-Api-Timestamp": timestamp,
        "Cdc-Api-Signature": signature,
    };
    if (body) {
        headers["Content-Type"] = "application/json";
    }
    return headers;
}

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

async function request(method: string, path: string, body?: unknown): Promise<ApiResponse> {
    const signPath = path.split("?")[0];
    const headers = getSignedHeaders(method, signPath, 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);
    }
});