@madeinusmate/grvt-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,700 @@
+// 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";
+
+// src/core/config/schema.ts
+import { z } from "zod";
+var environmentSchema = z.enum(["dev", "staging", "testnet", "prod"]);
+var httpConfigSchema = z.object({
+  timeoutMs: z.number().int().positive().default(1e4),
+  retries: z.number().int().min(0).default(3),
+  backoffMs: z.number().int().positive().default(200),
+  maxBackoffMs: z.number().int().positive().default(1e4)
+});
+var outputDefaultsSchema = z.object({
+  output: z.enum(["json", "ndjson", "table", "raw"]).default("table"),
+  pretty: z.boolean().default(false),
+  silent: z.boolean().default(false)
+});
+var configSchema = z.object({
+  env: environmentSchema.default("prod"),
+  apiKey: z.string().optional(),
+  privateKey: z.string().optional(),
+  subAccountId: z.string().optional(),
+  accountId: z.string().optional(),
+  cookie: z.string().optional(),
+  outputDefaults: outputDefaultsSchema.default({}),
+  http: httpConfigSchema.default({})
+});
+var DEFAULT_CONFIG = configSchema.parse({});
+
+// src/core/config/store.ts
+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 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 {
+  }
+};
+
+// 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/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/trade/orders.ts
+import { randomBytes } from "crypto";
+
+// src/core/output/table.ts
+import Table from "cli-table3";
+
+// src/core/output/colors.ts
+import chalk from "chalk";
+var _disabled = false;
+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 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);
+  }
+};
+
+// 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/confirm.ts
+import { createInterface } from "readline";
+
+// src/core/safety/validate.ts
+import { readFileSync as readFileSync2, readSync } from "fs";
+
+// src/core/instruments/cache.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+
+// src/core/signing/eip712.ts
+var PRICE_MULTIPLIER = 1000000000n;
+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 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 };
+};
+
+// src/core/signing/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+import { parseSignature } from "viem";
+
+// src/commands/trade/orders.ts
+var createOrder = async (client, order) => {
+  const body = { order };
+  const result = await client.post("trading", ENDPOINTS.trading.createOrder, body);
+  return result.result;
+};
+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);
+};
+
+// src/commands/trade/fills.ts
+var getFillHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.trading.fillHistory, params);
+};
+
+// src/commands/trade/positions.ts
+var getPositions = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.trading.positions, params);
+  return result.result;
+};
+
+// src/commands/trade/funding-payments.ts
+var getFundingPayments = async (client, params) => {
+  return client.post("trading", ENDPOINTS.trading.fundingPaymentHistory, params);
+};
+
+// 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 getSubAccountHistory = getSubAccountSummary;
+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;
+};
+
+// src/commands/funds/deposits.ts
+var createDeposit = async (_client, _params) => {
+  throw new Error("Deposit creation is not available via REST API. Use the GRVT web interface.");
+};
+var getDepositHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.depositHistory, params);
+};
+
+// src/core/currencies/cache.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var CACHE_TTL_MS2 = 60 * 60 * 1e3;
+var getCacheDir = () => {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  const base = xdgCache || join3(homedir3(), ".cache");
+  return join3(base, "grvt");
+};
+var getCachePath = (env) => join3(getCacheDir(), `currencies-${env}.json`);
+var loadCache = (env) => {
+  const path = getCachePath(env);
+  if (!existsSync3(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_MS2) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+};
+var saveCache = (env, currencies) => {
+  const dir = getCacheDir();
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const cache = { env, fetched_at: Date.now(), currencies };
+  writeFileSync3(getCachePath(env), JSON.stringify(cache), "utf-8");
+};
+var getCurrencies = async (env, cookie, accountId) => {
+  const cached = loadCache(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;
+  }
+  saveCache(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 createTransfer = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.funds.transfer, params);
+  return result.result;
+};
+var getTransferHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.transferHistory, params);
+};
+
+// src/commands/funds/withdrawals.ts
+var createWithdrawal = async (client, params) => {
+  const result = await client.post("trading", ENDPOINTS.funds.withdrawal, params);
+  return result.result;
+};
+var getWithdrawalHistory = async (client, params) => {
+  return client.post("trading", ENDPOINTS.funds.withdrawalHistory, params);
+};
+export {
+  ENDPOINTS,
+  buildDeriskTypedData,
+  buildTransferTypedData,
+  buildWithdrawalTypedData,
+  cancelAllOrders,
+  cancelOrder,
+  configSchema,
+  createDeposit,
+  createHttpClient,
+  createOrder,
+  createTransfer,
+  createWithdrawal,
+  getAccountHistory,
+  getAggregatedAccountSummary,
+  getCurrencies,
+  getCurrencyDecimals,
+  getCurrencyId,
+  getDepositHistory,
+  getFillHistory,
+  getFundingAccountSummary,
+  getFundingPayments,
+  getOpenOrders,
+  getOrder,
+  getOrderHistory,
+  getPositions,
+  getSubAccountHistory,
+  getSubAccountSummary,
+  getTransferHistory,
+  getWithdrawalHistory,
+  loadConfig,
+  login,
+  logout,
+  paginateCursor,
+  saveConfig,
+  verifySession
+};
+//# sourceMappingURL=index.js.map