@madeinusmate/grvt-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1880 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_CONFIG,
+  SECRET_KEYS,
+  configSchema,
+  redactConfig
+} from "./chunk-I7C5KKUG.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { parse as parseTOML2, stringify as stringifyTOML2 } from "smol-toml";
+
+// src/core/config/store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse as parseTOML, stringify as stringifyTOML } from "smol-toml";
+var getConfigDir = () => {
+  const xdgConfig = process.env["XDG_CONFIG_HOME"];
+  const base = xdgConfig || join(homedir(), ".config");
+  return join(base, "grvt");
+};
+var getConfigPath = () => join(getConfigDir(), "config.toml");
+var configPath = () => getConfigPath();
+var loadConfig = () => {
+  const path = getConfigPath();
+  if (!existsSync(path)) {
+    return DEFAULT_CONFIG;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const parsed = parseTOML(raw);
+  return configSchema.parse(parsed);
+};
+var saveConfig = (config) => {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const path = getConfigPath();
+  const toml = stringifyTOML(config);
+  writeFileSync(path, toml, { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+};
+var getConfigValue = (config, key) => {
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+};
+var setConfigValue = (config, key, value) => {
+  const parts = key.split(".");
+  const clone = structuredClone(config);
+  let current = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  const coerced = coerceValue(value, key);
+  current[lastKey] = coerced;
+  return configSchema.parse(clone);
+};
+var unsetConfigValue = (config, key) => {
+  const parts = key.split(".");
+  const clone = structuredClone(config);
+  let current = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof current[part] !== "object" || current[part] === null) {
+      return config;
+    }
+    current = current[part];
+  }
+  delete current[parts[parts.length - 1]];
+  return configSchema.parse(clone);
+};
+var NUMERIC_KEYS = /* @__PURE__ */ new Set([
+  "http.timeoutMs",
+  "http.retries",
+  "http.backoffMs",
+  "http.maxBackoffMs"
+]);
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set([
+  "outputDefaults.pretty",
+  "outputDefaults.silent"
+]);
+var coerceValue = (value, key) => {
+  if (BOOLEAN_KEYS.has(key) || value === "true" || value === "false") {
+    return value === "true";
+  }
+  if (NUMERIC_KEYS.has(key)) {
+    const num = Number(value);
+    if (!Number.isNaN(num)) return num;
+  }
+  return value;
+};
+
+// src/core/client/endpoints.ts
+var BASE_URLS = {
+  dev: {
+    edge: "https://edge.dev.gravitymarkets.io",
+    marketData: "https://market-data.dev.gravitymarkets.io",
+    trading: "https://trades.dev.gravitymarkets.io"
+  },
+  staging: {
+    edge: "https://edge.staging.gravitymarkets.io",
+    marketData: "https://market-data.staging.gravitymarkets.io",
+    trading: "https://trades.staging.gravitymarkets.io"
+  },
+  testnet: {
+    edge: "https://edge.testnet.grvt.io",
+    marketData: "https://market-data.testnet.grvt.io",
+    trading: "https://trades.testnet.grvt.io"
+  },
+  prod: {
+    edge: "https://edge.grvt.io",
+    marketData: "https://market-data.grvt.io",
+    trading: "https://trades.grvt.io"
+  }
+};
+var CHAIN_IDS = {
+  dev: { l1: 11155111, l2: 327 },
+  staging: { l1: 11155111, l2: 327 },
+  testnet: { l1: 11155111, l2: 326 },
+  prod: { l1: 1, l2: 325 }
+};
+var ENDPOINTS = {
+  auth: {
+    login: "/auth/api_key/login"
+  },
+  marketData: {
+    instrument: "/full/v1/instrument",
+    allInstruments: "/full/v1/all_instruments",
+    instruments: "/full/v1/instruments",
+    currency: "/full/v1/currency",
+    marginRules: "/full/v1/margin_rules",
+    mini: "/full/v1/mini",
+    ticker: "/full/v1/ticker",
+    tradeHistory: "/full/v1/trade_history",
+    kline: "/full/v1/kline",
+    funding: "/full/v1/funding",
+    book: "/full/v1/book"
+  },
+  trading: {
+    createOrder: "/full/v1/create_order",
+    cancelOrder: "/full/v1/cancel_order",
+    cancelAllOrders: "/full/v1/cancel_all_orders",
+    getOrder: "/full/v1/order",
+    openOrders: "/full/v1/open_orders",
+    orderHistory: "/full/v1/order_history",
+    cancelOnDisconnect: "/full/v1/cancel_on_disconnect",
+    fillHistory: "/full/v1/fill_history",
+    positions: "/full/v1/positions",
+    fundingPaymentHistory: "/full/v1/funding_payment_history",
+    getAllInitialLeverage: "/full/v1/get_all_initial_leverage",
+    setInitialLeverage: "/full/v1/set_initial_leverage",
+    setDeriskMmRatio: "/full/v1/set_derisk_mm_ratio"
+  },
+  account: {
+    accountSummary: "/full/v1/account_summary",
+    accountHistory: "/full/v1/account_history",
+    fundingAccountSummary: "/full/v1/funding_account_summary",
+    aggregatedAccountSummary: "/full/v1/aggregated_account_summary"
+  },
+  funds: {
+    depositHistory: "/full/v1/deposit_history",
+    transfer: "/full/v1/transfer",
+    transferHistory: "/full/v1/transfer_history",
+    withdrawal: "/full/v1/withdrawal",
+    withdrawalHistory: "/full/v1/withdrawal_history"
+  }
+};
+var getBaseUrls = (env) => BASE_URLS[env];
+var getChainIds = (env) => CHAIN_IDS[env];
+
+// src/core/client/http.ts
+var createHttpClient = (options) => {
+  const {
+    env,
+    cookie,
+    accountId,
+    timeoutMs = 1e4,
+    retries = 3,
+    backoffMs = 200,
+    maxBackoffMs = 1e4
+  } = options;
+  const urls = getBaseUrls(env);
+  const post = async (baseType, path, body) => {
+    const url = `${urls[baseType]}${path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (cookie) {
+      headers["Cookie"] = cookie;
+    }
+    if (accountId) {
+      headers["X-Grvt-Account-Id"] = accountId;
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (response.status === 429 || response.status >= 500) {
+          const err = new Error(`HTTP ${response.status}: ${response.statusText}`);
+          err.statusCode = response.status;
+          throw err;
+        }
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          const err = new Error(`HTTP ${response.status}: ${text || response.statusText}`);
+          err.statusCode = response.status;
+          throw err;
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const isRetryable = lastError.statusCode === 429 || (lastError.statusCode ?? 0) >= 500 || lastError.name === "AbortError";
+        if (!isRetryable || attempt >= retries) {
+          throw lastError;
+        }
+        const delay = Math.min(backoffMs * Math.pow(2, attempt), maxBackoffMs);
+        await sleep(delay);
+      }
+    }
+    throw lastError ?? new Error("Request failed");
+  };
+  return { post };
+};
+var extractAuthFromResponse = async (env, apiKey) => {
+  const urls = getBaseUrls(env);
+  const url = `${urls.edge}/auth/api_key/login`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: "rm=true;"
+    },
+    body: JSON.stringify({ api_key: apiKey }),
+    redirect: "manual"
+  });
+  const bodyText = await response.text().catch(() => "");
+  if (!response.ok && response.status !== 302) {
+    throw new Error(`Auth failed (HTTP ${response.status}): ${bodyText || response.statusText}`);
+  }
+  if (bodyText) {
+    try {
+      const bodyJson = JSON.parse(bodyText);
+      if (bodyJson["status"] === "failure" || bodyJson["error"]) {
+        throw new Error(`Auth failed: ${bodyJson["error"] ?? bodyJson["message"] ?? "unknown error"}`);
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Auth failed")) throw e;
+    }
+  }
+  const setCookies = response.headers.getSetCookie?.() ?? [];
+  let gravityCookie = setCookies.map((c2) => c2.split(";")[0]).find((c2) => c2?.startsWith("gravity="));
+  if (!gravityCookie) {
+    const rawSetCookie = response.headers.get("set-cookie");
+    if (rawSetCookie) {
+      const match = rawSetCookie.match(/gravity=[^;]+/);
+      if (match) {
+        gravityCookie = match[0];
+      }
+    }
+  }
+  if (!gravityCookie) {
+    throw new Error("Auth response did not contain gravity session cookie. Verify your API key is valid.");
+  }
+  const accountId = response.headers.get("x-grvt-account-id");
+  if (!accountId) {
+    throw new Error("Auth response did not contain X-Grvt-Account-Id header");
+  }
+  return { cookie: gravityCookie, accountId: accountId.trim() };
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/core/output/table.ts
+import Table from "cli-table3";
+
+// src/core/output/colors.ts
+import chalk from "chalk";
+var _disabled = false;
+var disableColors = () => {
+  _disabled = true;
+};
+var c = () => {
+  if (_disabled) {
+    return {
+      red: (s) => s,
+      green: (s) => s,
+      yellow: (s) => s,
+      cyan: { bold: (s) => s }
+    };
+  }
+  return chalk;
+};
+
+// src/core/output/table.ts
+var renderTable = (data) => {
+  if (data.length === 0) return "No data";
+  const keys = Object.keys(data[0]);
+  const table = new Table({
+    head: keys.map((k) => c().cyan.bold(k)),
+    style: { head: [], border: [] }
+  });
+  for (const row of data) {
+    table.push(keys.map((k) => formatCell(row[k])));
+  }
+  return table.toString();
+};
+var renderVerticalTable = (data) => {
+  const table = new Table({
+    style: { head: [], border: [] }
+  });
+  for (const [key, value] of Object.entries(data)) {
+    table.push({ [c().cyan.bold(key)]: formatCell(value) });
+  }
+  return table.toString();
+};
+var formatCell = (value) => {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+
+// src/core/output/format.ts
+var resolveOutputOptions = (opts) => {
+  const isTTY = process.stdout.isTTY ?? false;
+  const format = opts["output"] ?? (isTTY ? "table" : "json");
+  return {
+    output: format,
+    pretty: Boolean(opts["pretty"]),
+    silent: Boolean(opts["silent"])
+  };
+};
+var formatOutput = (data, options) => {
+  switch (options.output) {
+    case "json":
+      return options.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    case "ndjson":
+      if (Array.isArray(data)) {
+        return data.map((item) => JSON.stringify(item)).join("\n");
+      }
+      return JSON.stringify(data);
+    case "raw":
+      if (typeof data === "string") return data;
+      return JSON.stringify(data);
+    case "table":
+      if (Array.isArray(data)) {
+        if (data.length === 0) return "No data";
+        if (typeof data[0] === "object" && data[0] !== null) {
+          return renderTable(data);
+        }
+        return data.map(String).join("\n");
+      }
+      if (typeof data === "object" && data !== null) {
+        return renderVerticalTable(data);
+      }
+      return String(data);
+  }
+};
+var printOutput = (data, options) => {
+  const formatted = formatOutput(data, options);
+  process.stdout.write(formatted + "\n");
+};
+var logInfo = (message, silent) => {
+  if (!silent) {
+    process.stderr.write(message + "\n");
+  }
+};
+
+// src/core/output/errors.ts
+var EXIT_USAGE = 2;
+var EXIT_AUTH = 3;
+var EXIT_API = 5;
+var exitWithError = (message, code = EXIT_API) => {
+  process.stderr.write(c().red(`Error: ${message}
+`));
+  return process.exit(code);
+};
+var exitUsage = (message) => exitWithError(message, EXIT_USAGE);
+var exitAuth = (message) => exitWithError(message, EXIT_AUTH);
+var normalizeError = (error) => {
+  if (error instanceof Error) {
+    const httpErr = error;
+    if (httpErr.statusCode === 401 || httpErr.statusCode === 403) {
+      return { message: error.message, code: EXIT_AUTH };
+    }
+    if (httpErr.statusCode !== void 0) {
+      return { message: error.message, code: EXIT_API };
+    }
+    return { message: error.message, code: EXIT_API };
+  }
+  return { message: String(error), code: EXIT_API };
+};
+var handleCommandError = (error) => {
+  const { message, code } = normalizeError(error);
+  return exitWithError(message, code);
+};
+
+// src/core/command-helpers.ts
+var getGlobalOpts = (cmd) => {
+  let root = cmd;
+  while (root.parent) {
+    root = root.parent;
+  }
+  return root.opts();
+};
+var resolveContext = (cmd, requireAuth = true) => {
+  const globalOpts = getGlobalOpts(cmd);
+  if (globalOpts["color"] === false) {
+    disableColors();
+  }
+  const config = loadConfig();
+  const outputOptions = resolveOutputOptions(globalOpts);
+  const timeoutMs = Number(globalOpts["timeoutMs"]) || config.http.timeoutMs;
+  const retries = Number(globalOpts["retries"]) || config.http.retries;
+  if (requireAuth && (!config.cookie || !config.accountId)) {
+    exitAuth("Not authenticated. Run `grvt auth login` first.");
+  }
+  const client = createHttpClient({
+    env: config.env,
+    cookie: config.cookie,
+    accountId: config.accountId,
+    timeoutMs,
+    retries,
+    backoffMs: config.http.backoffMs,
+    maxBackoffMs: config.http.maxBackoffMs
+  });
+  return { config, client, outputOptions, globalOpts };
+};
+var wrapAction = (requireAuth, action) => async (...args) => {
+  const cmd = args[args.length - 1];
+  const opts = cmd.opts();
+  try {
+    const ctx = resolveContext(cmd, requireAuth);
+    await action(ctx, opts, cmd);
+  } catch (error) {
+    handleCommandError(error);
+  }
+};
+var output = (data, opts) => {
+  printOutput(data, opts);
+};
+var resolveSubAccountId = (opts, config) => {
+  const id = opts["subAccountId"] ?? config.subAccountId;
+  if (!id) {
+    exitAuth("--sub-account-id is required (or set subAccountId in config)");
+  }
+  return id;
+};
+
+// src/core/safety/confirm.ts
+import { createInterface } from "readline";
+var confirm = async (message, skipConfirm) => {
+  if (skipConfirm) return true;
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(c().yellow(`${message} [y/N] `), (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+};
+
+// src/commands/config.ts
+var registerConfigCommands = (program2) => {
+  const configCmd = program2.command("config").description("Manage local configuration");
+  configCmd.command("path").description("Print the config file path").action(() => {
+    process.stdout.write(configPath() + "\n");
+  });
+  configCmd.command("get").argument("[key]", "config key (dot-notation)").description("Get a config value").action(async (key, _opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      const outputOptions = resolveOutputOptions(globalOpts);
+      const config = loadConfig();
+      if (!key) {
+        printOutput(redactConfig(config), outputOptions);
+        return;
+      }
+      const value = getConfigValue(config, key);
+      if (value === void 0) {
+        exitUsage(`Key not found: ${key}`);
+      }
+      if (SECRET_KEYS.includes(key)) {
+        printOutput("****", outputOptions);
+      } else {
+        printOutput(value, outputOptions);
+      }
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  configCmd.command("set").argument("<key>", "config key (dot-notation)").argument("<value>", "value to set").description("Set a config value").action(async (key, value) => {
+    try {
+      const config = loadConfig();
+      const updated = setConfigValue(config, key, value);
+      saveConfig(updated);
+      process.stderr.write(`Set ${key}
+`);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  configCmd.command("unset").argument("<key>", "config key to unset").description("Unset a config value").action(async (key) => {
+    try {
+      const config = loadConfig();
+      const updated = unsetConfigValue(config, key);
+      saveConfig(updated);
+      process.stderr.write(`Unset ${key}
+`);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  configCmd.command("list").description("List all config values (secrets redacted)").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      const outputOptions = resolveOutputOptions(globalOpts);
+      printOutput(redactConfig(loadConfig()), outputOptions);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  configCmd.command("export").requiredOption("--file <path>", "path to export to").option("--include-secrets", "include secret values (apiKey, privateKey, cookie)").option("--yes", "skip confirmation").description("Export config to a file").action(async (opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      const skipConfirm = Boolean(opts.yes || globalOpts["yes"]);
+      const config = loadConfig();
+      if (opts.includeSecrets) {
+        const ok = await confirm("Export includes secrets. Continue?", skipConfirm);
+        if (!ok) {
+          process.stderr.write("Aborted.\n");
+          return;
+        }
+        const toml = stringifyTOML2(config);
+        writeFileSync2(opts.file, toml, "utf-8");
+      } else {
+        const toml = stringifyTOML2(redactConfig(config));
+        writeFileSync2(opts.file, toml, "utf-8");
+      }
+      process.stderr.write(`Exported to ${opts.file}
+`);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  configCmd.command("import").requiredOption("--file <path>", "path to import from").description("Import config from a file").action(async (opts) => {
+    try {
+      const raw = readFileSync2(opts.file, "utf-8");
+      const parsed = parseTOML2(raw);
+      const { configSchema: configSchema2 } = await import("./schema-LBUHKB7A.js");
+      const validated = configSchema2.parse(parsed);
+      saveConfig(validated);
+      process.stderr.write(`Imported from ${opts.file}
+`);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+};
+
+// src/core/auth/login.ts
+var performLogin = async (options) => {
+  const config = loadConfig();
+  const env = options.env ?? config.env;
+  const { cookie, accountId } = await extractAuthFromResponse(env, options.apiKey);
+  saveConfig({
+    ...config,
+    env,
+    apiKey: options.apiKey,
+    cookie,
+    accountId,
+    ...options.privateKey ? { privateKey: options.privateKey } : {}
+  });
+  return { accountId, env };
+};
+
+// src/core/auth/session.ts
+var login = async (options) => performLogin(options);
+var logout = () => {
+  const config = loadConfig();
+  saveConfig({
+    ...config,
+    apiKey: void 0,
+    privateKey: void 0,
+    cookie: void 0,
+    accountId: void 0
+  });
+};
+var verifySession = async () => {
+  const config = loadConfig();
+  if (!config.cookie || !config.accountId) {
+    return { valid: false, env: config.env };
+  }
+  try {
+    const client = createHttpClient({
+      env: config.env,
+      cookie: config.cookie,
+      accountId: config.accountId,
+      timeoutMs: config.http.timeoutMs
+    });
+    await client.post("trading", ENDPOINTS.account.fundingAccountSummary, {});
+    return { valid: true, env: config.env, accountId: config.accountId };
+  } catch {
+    return { valid: false, env: config.env, accountId: config.accountId };
+  }
+};
+
+// src/commands/auth.ts
+var registerAuthCommands = (program2) => {
+  const authCmd = program2.command("auth").description("Authentication and session management");
+  authCmd.command("login").description("Authenticate with GRVT API").option("--api-key <key>", "GRVT API key").option("--private-key <key>", "Ethereum private key for order signing").option("--env <environment>", "environment: dev|staging|testnet|prod").action(async (opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      const config = loadConfig();
+      const apiKey = opts.apiKey ?? config.apiKey;
+      if (!apiKey) {
+        return exitUsage("--api-key is required (or set apiKey in config)");
+      }
+      const env = opts.env ?? config.env;
+      logInfo(`Logging in to ${env}...`, Boolean(globalOpts["silent"]));
+      const result = await login({ apiKey, env, privateKey: opts.privateKey });
+      logInfo(c().green(`Authenticated on ${result.env} (accountId: ${result.accountId})`), Boolean(globalOpts["silent"]));
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  authCmd.command("status").description("Check if current session is valid").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      const outputOptions = resolveOutputOptions(globalOpts);
+      const status = await verifySession();
+      printOutput(status, outputOptions);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  authCmd.command("logout").description("Clear stored credentials and session").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      logout();
+      logInfo(c().green("Logged out."), Boolean(globalOpts["silent"]));
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+  authCmd.command("whoami").description("Show current account info").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = getGlobalOpts(cmd);
+      if (globalOpts["color"] === false) disableColors();
+      const outputOptions = resolveOutputOptions(globalOpts);
+      const config = loadConfig();
+      printOutput({
+        env: config.env,
+        accountId: config.accountId ?? "not set",
+        subAccountId: config.subAccountId ?? "not set",
+        hasApiKey: Boolean(config.apiKey),
+        hasPrivateKey: Boolean(config.privateKey),
+        hasSession: Boolean(config.cookie)
+      }, outputOptions);
+    } catch (error) {
+      handleCommandError(error);
+    }
+  });
+};
+
+// src/core/pagination/cursor.ts
+var paginateCursor = async (options) => {
+  const { fetchPage, all, outputOptions } = options;
+  let { cursor } = options;
+  if (!all) {
+    const page = await fetchPage(cursor);
+    return page.result;
+  }
+  const isStreaming = outputOptions.output === "ndjson";
+  const collected = [];
+  while (true) {
+    const page = await fetchPage(cursor);
+    if (isStreaming) {
+      for (const item of page.result) {
+        process.stdout.write(formatOutput(item, outputOptions) + "\n");
+      }
+    } else {
+      collected.push(...page.result);
+    }
+    if (!page.next || page.result.length === 0) {
+      break;
+    }
+    cursor = page.next;
+  }
+  return collected;
+};
+
+// src/core/safety/validate.ts
+import { readFileSync as readFileSync3, readSync } from "fs";
+var requireOption = (value, name) => {
+  if (value === void 0 || value === null || value === "") {
+    return exitUsage(`--${name} is required`);
+  }
+  return String(value);
+};
+var parseJsonInput = (jsonPath) => {
+  let raw;
+  if (jsonPath === "-") {
+    raw = readStdin();
+  } else {
+    const filePath = jsonPath.startsWith("@") ? jsonPath.slice(1) : jsonPath;
+    try {
+      raw = readFileSync3(filePath, "utf-8");
+    } catch (error) {
+      return exitUsage(`Cannot read file: ${filePath} (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return exitUsage("Invalid JSON input");
+  }
+};
+var readStdin = () => {
+  const chunks = [];
+  const fd = 0;
+  const buf = Buffer.alloc(4096);
+  let bytesRead;
+  try {
+    while ((bytesRead = readSync(fd, buf, 0, buf.length, null)) > 0) {
+      chunks.push(buf.subarray(0, bytesRead));
+    }
+  } catch {
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+};
+var parseTimestamp = (value) => {
+  const num = Number(value);
+  if (!Number.isNaN(num)) {
+    if (num < 1e12) {
+      return String(BigInt(num) * 1000000000n);
+    }
+    if (num < 1e15) {
+      return String(BigInt(num) * 1000000n);
+    }
+    return String(BigInt(num));
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return exitUsage(`Invalid timestamp: ${value}`);
+  }
+  return String(BigInt(date.getTime()) * 1000000n);
+};
+
+// src/commands/account.ts
+var getFundingAccountSummary = async (client) => {
+  const result = await client.post("trading", ENDPOINTS.account.fundingAccountSummary, {});
+  return result.result;
+};
+var getSubAccountSummary = async (client, subAccountId) => {
+  const body = { sub_account_id: subAccountId };
+  const result = await client.post("trading", ENDPOINTS.account.accountSummary, body);
+  return result.result;
+};
+var getAccountHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.account.accountHistory, params);
+};
+var getAggregatedAccountSummary = async (client) => {
+  const result = await client.post("trading", ENDPOINTS.account.aggregatedAccountSummary, {});
+  return result.result;
+};
+var registerAccountCommands = (program2) => {
+  const accountCmd = program2.command("account").description("Account summaries and sub-account info");
+  accountCmd.command("funding").description("Get funding account summary").action(wrapAction(true, async (ctx) => {
+    const result = await getFundingAccountSummary(ctx.client);
+    output(result, ctx.outputOptions);
+  }));
+  accountCmd.command("summary").description("Get sub-account summary").option("--sub-account-id <id>", "sub-account ID").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const result = await getSubAccountSummary(ctx.client, subAccountId);
+    output(result, ctx.outputOptions);
+  }));
+  accountCmd.command("aggregated").description("Get aggregated account summary across all sub-accounts").action(wrapAction(true, async (ctx) => {
+    const result = await getAggregatedAccountSummary(ctx.client);
+    output(result, ctx.outputOptions);
+  }));
+  accountCmd.command("history").description("Get hourly snapshots of sub-account state").option("--sub-account-id <id>", "sub-account ID").option("--start-time <time>", "start time (unix seconds, ms, ns, or ISO)").option("--end-time <time>", "end time").option("--limit <n>", "max results per page").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          sub_account_id: subAccountId,
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getAccountHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/market.ts
+var registerMarketCommands = (program2) => {
+  const marketCmd = program2.command("market").description("Market data (mostly unauthenticated)");
+  marketCmd.command("instruments").description("List instruments").option("--kind <kinds>", "filter by kind (comma-separated: PERPETUAL,FUTURE,CALL,PUT)").option("--base <currencies>", "filter by base currency (comma-separated)").option("--quote <currencies>", "filter by quote currency (comma-separated)").option("--active", "only active instruments", true).option("--limit <n>", "max results").action(wrapAction(false, async (ctx, opts) => {
+    const hasFilters = opts["kind"] || opts["base"] || opts["quote"];
+    const endpoint = hasFilters ? ENDPOINTS.marketData.instruments : ENDPOINTS.marketData.allInstruments;
+    const body = {
+      is_active: Boolean(opts["active"]),
+      ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+      ...opts["base"] ? { base: opts["base"].split(",") } : {},
+      ...opts["quote"] ? { quote: opts["quote"].split(",") } : {},
+      ...opts["limit"] ? { limit: Number(opts["limit"]) } : {}
+    };
+    const result = await ctx.client.post("marketData", endpoint, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("orderbook").description("Get order book").requiredOption("--instrument <name>", "instrument symbol").option("--depth <n>", "depth: 10, 50, 100, 500", "10").action(wrapAction(false, async (ctx, opts) => {
+    const body = {
+      instrument: opts["instrument"],
+      depth: Number(opts["depth"])
+    };
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.book, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("trades").description("Get trade history").requiredOption("--instrument <name>", "instrument symbol").option("--start-time <time>", "start time (unix seconds, ms, ns, or ISO)").option("--end-time <time>", "end time").option("--limit <n>", "max trades").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(false, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          instrument: opts["instrument"],
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const res = await ctx.client.post("marketData", ENDPOINTS.marketData.tradeHistory, body);
+        return { result: res.result ?? [], next: res.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+  marketCmd.command("candles").description("Get candlestick (OHLCV) data").requiredOption("--instrument <name>", "instrument symbol").requiredOption("--interval <interval>", "candle interval (e.g. CI_1_M, CI_5_M, CI_1_H, CI_1_D)").option("--type <type>", "price type: TRADE, MARK, INDEX, MID", "TRADE").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max candles").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(false, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          instrument: opts["instrument"],
+          interval: opts["interval"],
+          type: opts["type"] ?? "TRADE",
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const res = await ctx.client.post("marketData", ENDPOINTS.marketData.kline, body);
+        return { result: res.result ?? [], next: res.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+  marketCmd.command("funding-rate").description("Get funding rate history").requiredOption("--instrument <name>", "instrument symbol").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max entries").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(false, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          instrument: opts["instrument"],
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const res = await ctx.client.post("marketData", ENDPOINTS.marketData.funding, body);
+        return { result: res.result ?? [], next: res.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+  marketCmd.command("instrument").description("Get detailed metadata for a single instrument").requiredOption("--instrument <name>", "instrument symbol (e.g. BTC_USDT_Perp)").action(wrapAction(false, async (ctx, opts) => {
+    const body = { instrument: opts["instrument"] };
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.instrument, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("currency").description("List all supported currencies with IDs and decimals").action(wrapAction(false, async (ctx) => {
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.currency, {});
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("mini-ticker").description("Get lightweight price info for an instrument").requiredOption("--instrument <name>", "instrument symbol").action(wrapAction(false, async (ctx, opts) => {
+    const body = { instrument: opts["instrument"] };
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.mini, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("ticker").description("Get full ticker data for an instrument").requiredOption("--instrument <name>", "instrument symbol").option("--greeks", "include greeks data (for options)").option("--derived", "include derived data").action(wrapAction(false, async (ctx, opts) => {
+    const body = {
+      instrument: opts["instrument"],
+      ...opts["greeks"] ? { greeks: true } : {},
+      ...opts["derived"] ? { derived: true } : {}
+    };
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.ticker, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  marketCmd.command("margin-rules").description("Get margin rules for an instrument").requiredOption("--instrument <name>", "instrument symbol (e.g. BTC_USDT_Perp)").action(wrapAction(false, async (ctx, opts) => {
+    const body = { instrument: opts["instrument"] };
+    const result = await ctx.client.post("marketData", ENDPOINTS.marketData.marginRules, body);
+    output(result, ctx.outputOptions);
+  }));
+};
+
+// src/commands/trade/orders.ts
+import { randomBytes } from "crypto";
+
+// src/core/instruments/cache.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var getCacheDir = () => {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  const base = xdgCache || join2(homedir2(), ".cache");
+  return join2(base, "grvt");
+};
+var getCachePath = (env) => join2(getCacheDir(), `instruments-${env}.json`);
+var loadCache = (env) => {
+  const path = getCachePath(env);
+  if (!existsSync2(path)) return null;
+  try {
+    const raw = readFileSync4(path, "utf-8");
+    const cache = JSON.parse(raw);
+    if (cache.env !== env || Date.now() - cache.fetched_at > CACHE_TTL_MS) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+};
+var saveCache = (env, instruments) => {
+  const dir = getCacheDir();
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const cache = {
+    env,
+    fetched_at: Date.now(),
+    instruments
+  };
+  writeFileSync3(getCachePath(env), JSON.stringify(cache), "utf-8");
+};
+var getInstruments = async (env, cookie, accountId) => {
+  const cached = loadCache(env);
+  if (cached) return cached.instruments;
+  const client = createHttpClient({ env, cookie, accountId });
+  const response = await client.post(
+    "marketData",
+    ENDPOINTS.marketData.allInstruments,
+    { is_active: true }
+  );
+  const instruments = {};
+  for (const inst of response.result ?? []) {
+    instruments[inst.instrument] = inst;
+  }
+  saveCache(env, instruments);
+  return instruments;
+};
+var getInstrument = async (env, instrument, cookie, accountId) => {
+  const instruments = await getInstruments(env, cookie, accountId);
+  const meta = instruments[instrument];
+  if (!meta) {
+    throw new Error(`Instrument not found: ${instrument}. Run 'grvt market instruments' to see available instruments.`);
+  }
+  return meta;
+};
+
+// src/core/signing/eip712.ts
+var PRICE_MULTIPLIER = 1000000000n;
+var TIME_IN_FORCE_MAP = {
+  GOOD_TILL_TIME: 1,
+  ALL_OR_NONE: 2,
+  IMMEDIATE_OR_CANCEL: 3,
+  FILL_OR_KILL: 4
+};
+var decimalToBigInt = (value, multiplier) => {
+  const parts = value.split(".");
+  const whole = parts[0] ?? "0";
+  const frac = parts[1] ?? "";
+  const multiplierDigits = multiplier.toString().length - 1;
+  const paddedFrac = frac.padEnd(multiplierDigits, "0").slice(0, multiplierDigits);
+  return BigInt(whole) * multiplier + BigInt(paddedFrac);
+};
+var buildOrderTypedData = (payload, env) => {
+  const chainIds = getChainIds(env);
+  const domain = {
+    name: "GRVT Exchange",
+    version: "0",
+    chainId: BigInt(chainIds.l2)
+  };
+  const types = {
+    Order: [
+      { name: "subAccountID", type: "uint64" },
+      { name: "isMarket", type: "bool" },
+      { name: "timeInForce", type: "uint8" },
+      { name: "postOnly", type: "bool" },
+      { name: "reduceOnly", type: "bool" },
+      { name: "legs", type: "OrderLeg[]" },
+      { name: "nonce", type: "uint32" },
+      { name: "expiration", type: "int64" }
+    ],
+    OrderLeg: [
+      { name: "assetID", type: "uint256" },
+      { name: "contractSize", type: "uint64" },
+      { name: "limitPrice", type: "uint64" },
+      { name: "isBuyingContract", type: "bool" }
+    ]
+  };
+  const legs = payload.legs.map((leg) => {
+    const meta = payload.instruments[leg.instrument];
+    if (!meta) {
+      throw new Error(`Instrument metadata not found for: ${leg.instrument}`);
+    }
+    const sizeMultiplier = BigInt(10) ** BigInt(meta.base_decimals);
+    return {
+      assetID: BigInt(meta.instrument_hash),
+      contractSize: decimalToBigInt(leg.size, sizeMultiplier),
+      limitPrice: decimalToBigInt(leg.limit_price ?? "0", PRICE_MULTIPLIER),
+      isBuyingContract: leg.is_buying_asset
+    };
+  });
+  const message = {
+    subAccountID: BigInt(payload.subAccountId),
+    isMarket: payload.isMarket,
+    timeInForce: TIME_IN_FORCE_MAP[payload.timeInForce],
+    postOnly: payload.postOnly,
+    reduceOnly: payload.reduceOnly,
+    legs,
+    nonce: payload.nonce,
+    expiration: BigInt(payload.expiration)
+  };
+  return { domain, types, primaryType: "Order", message };
+};
+var buildTransferTypedData = (payload, env) => {
+  const chainIds = getChainIds(env);
+  const domain = {
+    name: "GRVT Exchange",
+    version: "0",
+    chainId: BigInt(chainIds.l2)
+  };
+  const types = {
+    Transfer: [
+      { name: "fromAccount", type: "address" },
+      { name: "fromSubAccount", type: "uint64" },
+      { name: "toAccount", type: "address" },
+      { name: "toSubAccount", type: "uint64" },
+      { name: "tokenCurrency", type: "uint8" },
+      { name: "numTokens", type: "uint64" },
+      { name: "nonce", type: "uint32" },
+      { name: "expiration", type: "int64" }
+    ]
+  };
+  const tokenMultiplier = BigInt(10) ** BigInt(payload.balanceDecimals);
+  const message = {
+    fromAccount: payload.fromAccount,
+    fromSubAccount: BigInt(payload.fromSubAccount),
+    toAccount: payload.toAccount,
+    toSubAccount: BigInt(payload.toSubAccount),
+    tokenCurrency: payload.tokenCurrency,
+    numTokens: decimalToBigInt(payload.numTokens, tokenMultiplier),
+    nonce: payload.nonce,
+    expiration: BigInt(payload.expiration)
+  };
+  return { domain, types, primaryType: "Transfer", message };
+};
+var buildWithdrawalTypedData = (payload, env) => {
+  const chainIds = getChainIds(env);
+  const domain = {
+    name: "GRVT Exchange",
+    version: "0",
+    chainId: BigInt(chainIds.l2)
+  };
+  const types = {
+    Withdrawal: [
+      { name: "fromAccount", type: "address" },
+      { name: "toEthAddress", type: "address" },
+      { name: "tokenCurrency", type: "uint8" },
+      { name: "numTokens", type: "uint64" },
+      { name: "nonce", type: "uint32" },
+      { name: "expiration", type: "int64" }
+    ]
+  };
+  const tokenMultiplier = BigInt(10) ** BigInt(payload.balanceDecimals);
+  const message = {
+    fromAccount: payload.fromAccount,
+    toEthAddress: payload.toEthAddress,
+    tokenCurrency: payload.tokenCurrency,
+    numTokens: decimalToBigInt(payload.numTokens, tokenMultiplier),
+    nonce: payload.nonce,
+    expiration: BigInt(payload.expiration)
+  };
+  return { domain, types, primaryType: "Withdrawal", message };
+};
+var buildDeriskTypedData = (payload, env) => {
+  const chainIds = getChainIds(env);
+  const domain = {
+    name: "GRVT Exchange",
+    version: "0",
+    chainId: BigInt(chainIds.l2)
+  };
+  const types = {
+    SetDeriskMMRatio: [
+      { name: "subAccountID", type: "uint64" },
+      { name: "ratio", type: "uint64" },
+      { name: "nonce", type: "uint32" },
+      { name: "expiration", type: "int64" }
+    ]
+  };
+  const message = {
+    subAccountID: BigInt(payload.subAccountId),
+    ratio: decimalToBigInt(payload.ratio, PRICE_MULTIPLIER),
+    nonce: payload.nonce,
+    expiration: BigInt(payload.expiration)
+  };
+  return { domain, types, primaryType: "SetDeriskMMRatio", message };
+};
+var generateNonce = () => Math.floor(Math.random() * 2147483647);
+var generateExpiration = (durationSeconds = 3600) => {
+  const expirationMs = Date.now() + durationSeconds * 1e3;
+  return String(BigInt(expirationMs) * 1000000n);
+};
+
+// src/core/signing/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+import { parseSignature } from "viem";
+var createSigner = (privateKey) => {
+  const key = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+  return privateKeyToAccount(key);
+};
+var signTypedData = async (privateKey, typedData) => {
+  const account = createSigner(privateKey);
+  const sig = await account.signTypedData(typedData);
+  const parsed = parseSignature(sig);
+  return {
+    signer: account.address,
+    r: parsed.r,
+    s: parsed.s,
+    v: Number(parsed.v)
+  };
+};
+
+// src/commands/trade/orders.ts
+var generateClientOrderId = () => {
+  const min = 2n ** 63n;
+  const range = 2n ** 63n;
+  const rand = BigInt(`0x${randomBytes(8).toString("hex")}`) % range;
+  return (min + rand).toString();
+};
+var cancelOrder = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.cancelOrder, params);
+  return result.result;
+};
+var cancelAllOrders = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.cancelAllOrders, params);
+  return result.result;
+};
+var getOrder = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.getOrder, params);
+  return result.result;
+};
+var getOpenOrders = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.openOrders, params);
+  return result.result;
+};
+var getOrderHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.trading.orderHistory, params);
+};
+var registerOrderCommands = (parent) => {
+  const orderCmd = parent.command("order").description("Order lifecycle management");
+  orderCmd.command("create").description("Create a new order").option("--sub-account-id <id>", "sub-account ID").requiredOption("--instrument <name>", "instrument symbol").requiredOption("--side <side>", "order side: buy|sell").requiredOption("--type <type>", "order type: market|limit").requiredOption("--qty <amount>", "order quantity").option("--price <price>", "limit price (required for limit orders)").option("--time-in-force <tif>", "GTT|IOC|AON|FOK", "GOOD_TILL_TIME").option("--reduce-only", "reduce-only order").option("--post-only", "post-only order").option("--client-order-id <id>", "client order ID (auto-generated if not set)").option("--expiration-seconds <n>", "order expiration in seconds", "3600").option("--json <path>", "read full request body from file (@path) or stdin (-)").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    let orderPayload;
+    if (opts["json"]) {
+      orderPayload = parseJsonInput(opts["json"]);
+    } else {
+      const subAccountId = resolveSubAccountId(opts, ctx.config);
+      const instrument = opts["instrument"];
+      const side = opts["side"].toUpperCase();
+      const type = opts["type"].toLowerCase();
+      const qty = opts["qty"];
+      const price = opts["price"];
+      if (type === "limit" && !price) {
+        exitUsage("--price is required for limit orders");
+      }
+      if (!ctx.config.privateKey) {
+        exitAuth("Private key required for order signing. Run `grvt config set privateKey <key>` or `grvt auth login --private-key <key>`.");
+      }
+      const instrumentMeta = await getInstrument(ctx.config.env, instrument, ctx.config.cookie, ctx.config.accountId);
+      const isMarket = type === "market";
+      const leg = {
+        instrument,
+        size: qty,
+        limit_price: isMarket ? "0" : price ?? "0",
+        is_buying_asset: side === "BUY"
+      };
+      const tifMap = {
+        GTT: "GOOD_TILL_TIME",
+        IOC: "IMMEDIATE_OR_CANCEL",
+        AON: "ALL_OR_NONE",
+        FOK: "FILL_OR_KILL",
+        GOOD_TILL_TIME: "GOOD_TILL_TIME",
+        IMMEDIATE_OR_CANCEL: "IMMEDIATE_OR_CANCEL",
+        ALL_OR_NONE: "ALL_OR_NONE",
+        FILL_OR_KILL: "FILL_OR_KILL"
+      };
+      const tifInput = opts["timeInForce"] ?? "GOOD_TILL_TIME";
+      const timeInForce = tifMap[tifInput.toUpperCase()];
+      if (!timeInForce) {
+        return exitUsage(`Invalid time-in-force: ${tifInput}. Use GTT, IOC, AON, or FOK.`);
+      }
+      const nonce = generateNonce();
+      const expiration = generateExpiration(Number(opts["expirationSeconds"] ?? 3600));
+      const clientOrderId = opts["clientOrderId"] ?? generateClientOrderId();
+      const typedData = buildOrderTypedData({
+        subAccountId,
+        isMarket,
+        timeInForce,
+        postOnly: Boolean(opts["postOnly"]),
+        reduceOnly: Boolean(opts["reduceOnly"]),
+        legs: [leg],
+        instruments: {
+          [instrument]: {
+            instrument_hash: instrumentMeta.instrument_hash,
+            base_decimals: instrumentMeta.base_decimals ?? 9
+          }
+        },
+        expiration,
+        nonce
+      }, ctx.config.env);
+      const sigComponents = await signTypedData(ctx.config.privateKey, typedData);
+      orderPayload = {
+        order: {
+          sub_account_id: subAccountId,
+          is_market: isMarket,
+          time_in_force: timeInForce,
+          post_only: Boolean(opts["postOnly"]),
+          reduce_only: Boolean(opts["reduceOnly"]),
+          legs: [leg],
+          signature: {
+            signer: sigComponents.signer,
+            r: sigComponents.r,
+            s: sigComponents.s,
+            v: sigComponents.v,
+            expiration,
+            nonce
+          },
+          metadata: { client_order_id: clientOrderId }
+        }
+      };
+    }
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(orderPayload, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const result = await ctx.client.post("trading", ENDPOINTS.trading.createOrder, orderPayload);
+    output(result.result, ctx.outputOptions);
+  }));
+  orderCmd.command("get").description("Get an order by ID").option("--sub-account-id <id>", "sub-account ID").option("--order-id <id>", "order ID").option("--client-order-id <id>", "client order ID").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    if (!opts["orderId"] && !opts["clientOrderId"]) {
+      exitUsage("Either --order-id or --client-order-id is required");
+    }
+    const body = {
+      sub_account_id: subAccountId,
+      ...opts["orderId"] ? { order_id: opts["orderId"] } : {},
+      ...opts["clientOrderId"] ? { client_order_id: opts["clientOrderId"] } : {}
+    };
+    const result = await getOrder(ctx.client, body);
+    output(result, ctx.outputOptions);
+  }));
+  orderCmd.command("open").description("List open orders").option("--sub-account-id <id>", "sub-account ID").option("--kind <kinds>", "filter by kind (comma-separated)").option("--base <currencies>", "filter by base currency").option("--quote <currencies>", "filter by quote currency").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const body = {
+      sub_account_id: subAccountId,
+      ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+      ...opts["base"] ? { base: opts["base"].split(",") } : {},
+      ...opts["quote"] ? { quote: opts["quote"].split(",") } : {}
+    };
+    const result = await getOpenOrders(ctx.client, body);
+    output(result, ctx.outputOptions);
+  }));
+  orderCmd.command("cancel").description("Cancel a single order").option("--sub-account-id <id>", "sub-account ID").option("--order-id <id>", "order ID").option("--client-order-id <id>", "client order ID").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    if (!opts["orderId"] && !opts["clientOrderId"]) {
+      exitUsage("Either --order-id or --client-order-id is required");
+    }
+    const body = {
+      sub_account_id: subAccountId,
+      ...opts["orderId"] ? { order_id: opts["orderId"] } : {},
+      ...opts["clientOrderId"] ? { client_order_id: opts["clientOrderId"] } : {}
+    };
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(body, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const result = await cancelOrder(ctx.client, body);
+    output(result, ctx.outputOptions);
+  }));
+  orderCmd.command("cancel-all").description("Cancel all open orders").option("--sub-account-id <id>", "sub-account ID").option("--instrument <name>", "filter by instrument").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const body = {
+      sub_account_id: subAccountId,
+      ...opts["instrument"] ? { instrument: opts["instrument"] } : {}
+    };
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(body, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const skipConfirm = Boolean(ctx.globalOpts["yes"]);
+    const ok = await confirm("Cancel ALL open orders?", skipConfirm);
+    if (!ok) {
+      logInfo("Aborted.", Boolean(ctx.globalOpts["silent"]));
+      return;
+    }
+    const result = await cancelAllOrders(ctx.client, body);
+    output(result, ctx.outputOptions);
+  }));
+  orderCmd.command("history").description("Get order history").option("--sub-account-id <id>", "sub-account ID").option("--kind <kinds>", "filter by kind (comma-separated)").option("--base <currencies>", "filter by base currency").option("--quote <currencies>", "filter by quote currency").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          sub_account_id: subAccountId,
+          ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+          ...opts["base"] ? { base: opts["base"].split(",") } : {},
+          ...opts["quote"] ? { quote: opts["quote"].split(",") } : {},
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getOrderHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/trade/fills.ts
+var getFillHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.trading.fillHistory, params);
+};
+var registerFillCommands = (parent) => {
+  parent.command("fills").description("Get fill (trade execution) history").option("--sub-account-id <id>", "sub-account ID").option("--kind <kinds>", "filter by kind (comma-separated)").option("--base <currencies>", "filter by base currency").option("--quote <currencies>", "filter by quote currency").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          sub_account_id: subAccountId,
+          ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+          ...opts["base"] ? { base: opts["base"].split(",") } : {},
+          ...opts["quote"] ? { quote: opts["quote"].split(",") } : {},
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getFillHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/trade/positions.ts
+var getPositions = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.positions, params);
+  return result.result;
+};
+var registerPositionCommands = (parent) => {
+  parent.command("positions").description("Get current positions").option("--sub-account-id <id>", "sub-account ID").option("--kind <kinds>", "filter by kind (comma-separated)").option("--base <currencies>", "filter by base currency").option("--quote <currencies>", "filter by quote currency").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const body = {
+      sub_account_id: subAccountId,
+      ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+      ...opts["base"] ? { base: opts["base"].split(",") } : {},
+      ...opts["quote"] ? { quote: opts["quote"].split(",") } : {}
+    };
+    const result = await getPositions(ctx.client, body);
+    output(result, ctx.outputOptions);
+  }));
+};
+
+// src/commands/trade/funding-payments.ts
+var getFundingPayments = async (client, params) => {
+  return client.post("trading", ENDPOINTS.trading.fundingPaymentHistory, params);
+};
+var registerFundingPaymentCommands = (parent) => {
+  parent.command("funding-payments").description("Get funding payment history").option("--sub-account-id <id>", "sub-account ID").option("--kind <kinds>", "filter by kind (comma-separated)").option("--base <currencies>", "filter by base currency").option("--quote <currencies>", "filter by quote currency").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          sub_account_id: subAccountId,
+          ...opts["kind"] ? { kind: opts["kind"].split(",") } : {},
+          ...opts["base"] ? { base: opts["base"].split(",") } : {},
+          ...opts["quote"] ? { quote: opts["quote"].split(",") } : {},
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getFundingPayments(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/trade/leverage.ts
+var registerLeverageCommands = (parent) => {
+  const leverageCmd = parent.command("leverage").description("Leverage settings");
+  leverageCmd.command("get").description("Get initial leverage settings for all instruments (or one)").option("--sub-account-id <id>", "sub-account ID").option("--instrument <name>", "filter by instrument (client-side)").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const body = { sub_account_id: subAccountId };
+    const result = await ctx.client.post("trading", ENDPOINTS.trading.getAllInitialLeverage, body);
+    const data = result.result;
+    const instrument = opts["instrument"];
+    if (instrument && Array.isArray(data)) {
+      const filtered = data.filter((entry) => entry["instrument"] === instrument);
+      output(filtered.length === 1 ? filtered[0] : filtered, ctx.outputOptions);
+    } else {
+      output(data, ctx.outputOptions);
+    }
+  }));
+  leverageCmd.command("set").description("Set initial leverage for an instrument").requiredOption("--instrument <name>", "instrument symbol").requiredOption("--leverage <value>", "leverage value (e.g. 10)").option("--sub-account-id <id>", "sub-account ID").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const body = {
+      sub_account_id: subAccountId,
+      instrument: opts["instrument"],
+      leverage: opts["leverage"]
+    };
+    const result = await ctx.client.post("trading", ENDPOINTS.trading.setInitialLeverage, body);
+    output(result.result, ctx.outputOptions);
+  }));
+};
+
+// src/commands/trade/cancel-on-disconnect.ts
+var registerCancelOnDisconnectCommands = (parent) => {
+  parent.command("cancel-on-disconnect").description("Set, refresh, or disable cancel-on-disconnect countdown (1000\u2013300000ms, 0 to disable)").requiredOption("--countdown <ms>", "countdown in milliseconds (0 to disable)").option("--sub-account-id <id>", "sub-account ID").action(wrapAction(true, async (ctx, opts) => {
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const countdown = Number(opts["countdown"]);
+    if (isNaN(countdown) || countdown < 0) {
+      return exitUsage("--countdown must be a non-negative integer (ms)");
+    }
+    if (countdown !== 0 && (countdown < 1e3 || countdown > 3e5)) {
+      return exitUsage("--countdown must be 0 (disable) or between 1000 and 300000 ms");
+    }
+    const body = {
+      sub_account_id: subAccountId,
+      countdown_time_ms: countdown
+    };
+    const result = await ctx.client.post("trading", ENDPOINTS.trading.cancelOnDisconnect, body);
+    output(result.result, ctx.outputOptions);
+  }));
+};
+
+// src/commands/trade/derisk.ts
+var registerDeriskCommands = (parent) => {
+  parent.command("derisk").description("Set derisk-to-maintenance-margin ratio").requiredOption("--ratio <value>", "derisk MM ratio (decimal, e.g. 0.5)").option("--sub-account-id <id>", "sub-account ID").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    if (!ctx.config.privateKey) {
+      exitAuth("Private key required for derisk signing. Run `grvt config set privateKey <key>`.");
+    }
+    const subAccountId = resolveSubAccountId(opts, ctx.config);
+    const ratio = opts["ratio"];
+    const nonce = generateNonce();
+    const expiration = generateExpiration(3600);
+    const typedData = buildDeriskTypedData({
+      subAccountId,
+      ratio,
+      expiration,
+      nonce
+    }, ctx.config.env);
+    const sigComponents = await signTypedData(ctx.config.privateKey, typedData);
+    const body = {
+      sub_account_id: subAccountId,
+      ratio,
+      signature: {
+        signer: sigComponents.signer,
+        r: sigComponents.r,
+        s: sigComponents.s,
+        v: sigComponents.v,
+        expiration,
+        nonce
+      }
+    };
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(body, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const result = await ctx.client.post("trading", ENDPOINTS.trading.setDeriskMmRatio, body);
+    output(result.result, ctx.outputOptions);
+  }));
+};
+
+// src/commands/trade/index.ts
+var registerTradeCommands = (program2) => {
+  const tradeCmd = program2.command("trade").description("Trading: orders, fills, positions, funding, leverage, derisk");
+  registerOrderCommands(tradeCmd);
+  registerFillCommands(tradeCmd);
+  registerPositionCommands(tradeCmd);
+  registerFundingPaymentCommands(tradeCmd);
+  registerLeverageCommands(tradeCmd);
+  registerCancelOnDisconnectCommands(tradeCmd);
+  registerDeriskCommands(tradeCmd);
+};
+
+// src/commands/funds/deposits.ts
+var getDepositHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.depositHistory, params);
+};
+var registerDepositCommands = (parent) => {
+  const depositCmd = parent.command("deposit").description("Deposit management");
+  depositCmd.command("history").description("Get deposit history").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getDepositHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/core/currencies/cache.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var CACHE_TTL_MS2 = 60 * 60 * 1e3;
+var getCacheDir2 = () => {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  const base = xdgCache || join3(homedir3(), ".cache");
+  return join3(base, "grvt");
+};
+var getCachePath2 = (env) => join3(getCacheDir2(), `currencies-${env}.json`);
+var loadCache2 = (env) => {
+  const path = getCachePath2(env);
+  if (!existsSync3(path)) return null;
+  try {
+    const raw = readFileSync5(path, "utf-8");
+    const cache = JSON.parse(raw);
+    if (cache.env !== env || Date.now() - cache.fetched_at > CACHE_TTL_MS2) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+};
+var saveCache2 = (env, currencies) => {
+  const dir = getCacheDir2();
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const cache = { env, fetched_at: Date.now(), currencies };
+  writeFileSync4(getCachePath2(env), JSON.stringify(cache), "utf-8");
+};
+var getCurrencies = async (env, cookie, accountId) => {
+  const cached = loadCache2(env);
+  if (cached) return cached.currencies;
+  const client = createHttpClient({ env, cookie, accountId });
+  const response = await client.post(
+    "marketData",
+    ENDPOINTS.marketData.currency,
+    {}
+  );
+  const currencies = {};
+  for (const cur of response.result ?? []) {
+    currencies[cur.symbol] = cur;
+  }
+  saveCache2(env, currencies);
+  return currencies;
+};
+var getCurrencyId = async (env, symbol, cookie, accountId) => {
+  const currencies = await getCurrencies(env, cookie, accountId);
+  const cur = currencies[symbol.toUpperCase()];
+  if (!cur) {
+    throw new Error(`Currency not found: ${symbol}. Run 'grvt market currency' to see available currencies.`);
+  }
+  return cur.id;
+};
+var getCurrencyDecimals = async (env, symbol, cookie, accountId) => {
+  const currencies = await getCurrencies(env, cookie, accountId);
+  const cur = currencies[symbol.toUpperCase()];
+  if (!cur) {
+    throw new Error(`Currency not found: ${symbol}. Run 'grvt market currency' to see available currencies.`);
+  }
+  return cur.balance_decimals;
+};
+
+// src/commands/funds/transfers.ts
+var getTransferHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.transferHistory, params);
+};
+var registerTransferCommands = (parent) => {
+  const transferCmd = parent.command("transfer").description("Transfer management");
+  transferCmd.command("create").description("Transfer between sub-accounts").requiredOption("--from-sub-account-id <id>", "source sub-account ID").requiredOption("--to-sub-account-id <id>", "destination sub-account ID").requiredOption("--currency <symbol>", "currency to transfer (e.g. USDT)").requiredOption("--amount <amount>", "amount to transfer").option("--json <path>", "read full request body from file (@path) or stdin (-)").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    let body;
+    if (opts["json"]) {
+      body = parseJsonInput(opts["json"]);
+    } else {
+      if (!ctx.config.privateKey) {
+        exitAuth("Private key required for transfer signing. Run `grvt config set privateKey <key>`.");
+      }
+      const fromSubAccountId = requireOption(opts["fromSubAccountId"], "from-sub-account-id");
+      const toSubAccountId = requireOption(opts["toSubAccountId"], "to-sub-account-id");
+      const currency = opts["currency"].toUpperCase();
+      const amount = opts["amount"];
+      const fromAccount = ctx.config.accountId;
+      const toAccount = fromAccount;
+      const signerAccount = createSigner(ctx.config.privateKey);
+      const tokenCurrency = await getCurrencyId(ctx.config.env, currency, ctx.config.cookie, ctx.config.accountId);
+      const balanceDecimals = await getCurrencyDecimals(ctx.config.env, currency, ctx.config.cookie, ctx.config.accountId);
+      const nonce = generateNonce();
+      const expiration = generateExpiration(3600);
+      const typedData = buildTransferTypedData({
+        fromAccount: signerAccount.address,
+        fromSubAccount: fromSubAccountId,
+        toAccount: signerAccount.address,
+        toSubAccount: toSubAccountId,
+        tokenCurrency,
+        numTokens: amount,
+        balanceDecimals,
+        expiration,
+        nonce
+      }, ctx.config.env);
+      const sigComponents = await signTypedData(ctx.config.privateKey, typedData);
+      body = {
+        from_account_id: fromAccount,
+        from_sub_account_id: fromSubAccountId,
+        to_account_id: toAccount,
+        to_sub_account_id: toSubAccountId,
+        currency,
+        num_tokens: amount,
+        signature: {
+          signer: sigComponents.signer,
+          r: sigComponents.r,
+          s: sigComponents.s,
+          v: sigComponents.v,
+          expiration,
+          nonce
+        }
+      };
+    }
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(body, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const skipConfirm = Boolean(ctx.globalOpts["yes"]);
+    const ok = await confirm(
+      `Transfer ${body["num_tokens"]} ${body["currency"]} from ${body["from_sub_account_id"]} to ${body["to_sub_account_id"]}?`,
+      skipConfirm
+    );
+    if (!ok) {
+      logInfo("Aborted.", Boolean(ctx.globalOpts["silent"]));
+      return;
+    }
+    const result = await ctx.client.post("trading", ENDPOINTS.funds.transfer, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  transferCmd.command("history").description("Get transfer history").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getTransferHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/funds/withdrawals.ts
+var getWithdrawalHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.withdrawalHistory, params);
+};
+var registerWithdrawalCommands = (parent) => {
+  const withdrawCmd = parent.command("withdraw").description("Withdrawal management");
+  withdrawCmd.command("create").description("Withdraw from sub-account to Ethereum address").option("--sub-account-id <id>", "source sub-account ID").requiredOption("--to-address <address>", "destination Ethereum address").requiredOption("--currency <symbol>", "currency to withdraw (e.g. USDT)").requiredOption("--amount <amount>", "amount to withdraw").option("--main-account-id <id>", "main account ID (defaults to current account)").option("--json <path>", "read full request body from file (@path) or stdin (-)").option("--dry-run", "validate and show payload without sending").action(wrapAction(true, async (ctx, opts) => {
+    let body;
+    if (opts["json"]) {
+      body = parseJsonInput(opts["json"]);
+    } else {
+      if (!ctx.config.privateKey) {
+        exitAuth("Private key required for withdrawal signing. Run `grvt config set privateKey <key>`.");
+      }
+      const toAddress = opts["toAddress"];
+      if (!toAddress.startsWith("0x") || toAddress.length !== 42) {
+        exitUsage("--to-address must be a valid Ethereum address (0x...)");
+      }
+      const subAccountId = opts["subAccountId"] ?? ctx.config.subAccountId;
+      if (!subAccountId) {
+        exitUsage("--sub-account-id is required (or set subAccountId in config)");
+      }
+      const mainAccountId = opts["mainAccountId"] ?? requireOption(ctx.config.accountId, "main-account-id");
+      const currency = opts["currency"].toUpperCase();
+      const amount = opts["amount"];
+      const signerAccount = createSigner(ctx.config.privateKey);
+      const tokenCurrency = await getCurrencyId(ctx.config.env, currency, ctx.config.cookie, ctx.config.accountId);
+      const balanceDecimals = await getCurrencyDecimals(ctx.config.env, currency, ctx.config.cookie, ctx.config.accountId);
+      const nonce = generateNonce();
+      const expiration = generateExpiration(3600);
+      const typedData = buildWithdrawalTypedData({
+        fromAccount: signerAccount.address,
+        toEthAddress: toAddress,
+        tokenCurrency,
+        numTokens: amount,
+        balanceDecimals,
+        expiration,
+        nonce
+      }, ctx.config.env);
+      const sigComponents = await signTypedData(ctx.config.privateKey, typedData);
+      body = {
+        main_account_id: mainAccountId,
+        from_sub_account_id: subAccountId,
+        to_eth_address: toAddress,
+        currency,
+        num_tokens: amount,
+        signature: {
+          signer: sigComponents.signer,
+          r: sigComponents.r,
+          s: sigComponents.s,
+          v: sigComponents.v,
+          expiration,
+          nonce
+        }
+      };
+    }
+    if (opts["dryRun"]) {
+      logInfo("Dry run - payload that would be sent:", Boolean(ctx.globalOpts["silent"]));
+      printOutput(body, { ...ctx.outputOptions, output: "json", pretty: true });
+      return;
+    }
+    const skipConfirm = Boolean(ctx.globalOpts["yes"]);
+    const ok = await confirm(
+      `Withdraw ${body["num_tokens"]} ${body["currency"]} to ${body["to_eth_address"]}?`,
+      skipConfirm
+    );
+    if (!ok) {
+      logInfo("Aborted.", Boolean(ctx.globalOpts["silent"]));
+      return;
+    }
+    const result = await ctx.client.post("trading", ENDPOINTS.funds.withdrawal, body);
+    output(result.result, ctx.outputOptions);
+  }));
+  withdrawCmd.command("history").description("Get withdrawal history").option("--start-time <time>", "start time").option("--end-time <time>", "end time").option("--limit <n>", "max results").option("--cursor <cursor>", "pagination cursor").option("--all", "auto-paginate all results").action(wrapAction(true, async (ctx, opts) => {
+    const results = await paginateCursor({
+      fetchPage: async (cursor) => {
+        const body = {
+          ...opts["startTime"] ? { start_time: parseTimestamp(opts["startTime"]) } : {},
+          ...opts["endTime"] ? { end_time: parseTimestamp(opts["endTime"]) } : {},
+          ...opts["limit"] ? { limit: Number(opts["limit"]) } : {},
+          ...cursor ? { cursor } : {}
+        };
+        const resp = await getWithdrawalHistory(ctx.client, body);
+        return { result: resp.result ?? [], next: resp.next };
+      },
+      cursor: opts["cursor"],
+      all: Boolean(opts["all"]),
+      outputOptions: ctx.outputOptions
+    });
+    if (ctx.outputOptions.output !== "ndjson" || !opts["all"]) {
+      output(results, ctx.outputOptions);
+    }
+  }));
+};
+
+// src/commands/funds/index.ts
+var registerFundsCommands = (program2) => {
+  const fundsCmd = program2.command("funds").description("Fund management: deposits, transfers, withdrawals");
+  registerDepositCommands(fundsCmd);
+  registerTransferCommands(fundsCmd);
+  registerWithdrawalCommands(fundsCmd);
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("grvt").description("CLI tool to trade on GRVT markets").version("0.1.0").option("--output <format>", "output format: json|ndjson|table|raw", "table").option("--pretty", "pretty-print JSON output").option("--silent", "suppress logs, only data to stdout").option("--no-color", "disable colored output").option("--yes", "skip confirmation prompts").option("--retries <n>", "number of retries on failure", "3").option("--timeout-ms <n>", "request timeout in milliseconds", "10000");
+registerConfigCommands(program);
+registerAuthCommands(program);
+registerAccountCommands(program);
+registerMarketCommands(program);
+registerTradeCommands(program);
+registerFundsCommands(program);
+program.parse();
+//# sourceMappingURL=cli.js.map