@2bad/walt 1.0.1 → 2.0.0

package/README.md

@@ -42,6 +42,7 @@ await source.disconnect()
 - [Exchange](examples/exchange.md): available pairs, quotes, exchanges and limit orders
 - [Transactions](examples/transactions.md): history, details and reading a transaction
 - [Errors](examples/errors.md): `WaltRequestError`, `WaltAuthError` and what is retried
+- [Command line](examples/cli.md): the read-only `walt` command for balances, history, prices and orders
 
 A runnable script is in [examples/portfolio.ts](examples/portfolio.ts).
 
@@ -60,6 +61,7 @@ new WaltClient(options: WaltClientOptions)
 type WaltClient = {
   accounts(): Promise<AccountsResponse>
   portfolio(): Promise<Portfolio>
+  balances(fiatCurrency: FiatCurrency): Promise<Balances>
   pnl(): Promise<PnlResponse>
   portfolioHistory(dateFrom: Date | string, resolution: '1d' | '1m'): Promise<PortfolioHistory>
   frozenBalances<T = unknown>(): Promise<T[]>
@@ -74,6 +76,7 @@ type WaltClient = {
   charts(currency: string, fiatCurrency: FiatCurrency): Promise<Charts>
   priceForFiatAtTime(crypto: string, fiat: FiatCurrency, amount: number | string, time: Date | string | number): Promise<PriceAtTime>
   localCurrency(): Promise<FiatCurrency>
+  candles(requests: CandleRequest[]): Promise<CandleSeries[]>
 
   availableExchanges(): Promise<AvailableExchanges>
   quote(fromCurrency: string, toCurrency: string, fromAmount: number): Promise<ExchangeQuote>
@@ -85,6 +88,11 @@ type WaltClient = {
   limitOrderBounds(baseCurrency: string): Promise<LimitOrderBounds>
   limitOrderTokens(): Promise<LimitOrderToken[]>
 
+  perpContracts(contractId?: number): Promise<PerpContract[]>
+  perpSystemStatus(): Promise<PerpSystemStatus>
+  perpPositions(options?: { statuses?: PerpPositionStatus[]; contractId?: number }): Promise<PerpPosition[]>
+  perpOrders(options?: { contractId?: number; statuses?: PerpOrderStatus[]; limit?: number }): Promise<PerpOrdersPage>
+
   transactions(limit?: number, cursor?: string): Promise<TransactionsPage>
   accountTransactions(currency: string, limit?: number, cursor?: string): Promise<TransactionsPage>
   allTransactions(limit?: number): AsyncGenerator<Transaction>

package/build/api/balances.d.ts

@@ -0,0 +1,23 @@
+export type Balance = {
+  /** `REGULAR` for spot, `HOLD_LIMIT` for USDT reserved by open limit orders, `EARN_V2` for staked funds. */
+  account_type: string;
+  currency: string;
+  asset_currency: string;
+  total_balance: string;
+  available_balance: string;
+  balance_hold: string;
+  is_always_on_main: boolean;
+  category: string;
+  rate_to_fiat: string;
+  rate_to_usd: string;
+  available_balance_fiat_amount: string;
+  available_balance_usd_amount: string;
+};
+export type Balances = {
+  accounts: Balance[];
+  fiat_currency: string;
+  /** Spot, staked and limit order holds together. */
+  overall_available_balance_fiat_amount: string;
+  /** Also `true` when the perps account has no open position. */
+  has_open_perp_position: boolean;
+};

package/build/api/balances.js

@@ -0,0 +1 @@
+export {};

package/build/api/candles.d.ts

@@ -0,0 +1,21 @@
+export type CandleRequest = {
+  /** `<currency>/USD/SPOT`, or `<base>/USD/PERP_TRADE` for a perps contract. */
+  ticker: string;
+  /** Seen: `5m`, `15m`. */
+  resolution: string;
+  limit: number;
+};
+export type Candle = {
+  o: string;
+  h: string;
+  l: string;
+  c: string;
+  v: string;
+};
+export type CandleSeries = {
+  ticker: string;
+  resolution: string;
+  /** Opening time of the first candle, in ms. */
+  start_ts: number;
+  candles: Candle[];
+};

package/build/api/candles.js

@@ -0,0 +1 @@
+export {};

package/build/api/perps.d.ts

@@ -0,0 +1,155 @@
+export type PerpContract = {
+  contract_id: number;
+  contract_name: string;
+  base_asset: string;
+  quote_asset: string;
+  venue_status: string;
+  is_active: boolean;
+  price_decimals: number;
+  size_decimals: number;
+  tick_size: string;
+  step_size: string;
+  min_size_base: string;
+  max_size_base: string;
+  max_size_quote: string;
+  min_size_quote: string;
+  max_leverage: number;
+  maker_fee_pct: string;
+  taker_fee_pct: string;
+  base_taker_fee_pct: string;
+  taker_fee_subscription_id: number;
+  price_slippage: string;
+  tpsl_buffer_pct: string;
+  funding_rate_hourly: string;
+  next_funding_at: string;
+  open_interest_usd: string;
+  volume_24h_usd: string;
+  trading_hours_state: unknown;
+  market_data: {
+    server_time: string;
+    /** `fresh`, or `stale` with both prices `null`. */
+    status: string;
+    mark_price: string | null;
+    index_price: string | null;
+    source_timestamp: string;
+    expires_at: string;
+  };
+  /** Fractions in basis points: `1000` is 10%, so 10x leverage. */
+  margin: {
+    default_initial_margin_fraction: number;
+    min_initial_margin_fraction: number;
+    maintenance_margin_fraction: number;
+    closeout_margin_fraction: number;
+  };
+};
+export type PerpSystemStatus = {
+  actions: {
+    open_enabled: boolean;
+    cancel_enabled: boolean;
+    close_enabled: boolean;
+    add_margin_enabled: boolean;
+    remove_margin_enabled: boolean;
+    auto_close_enabled: boolean;
+  };
+  exchange_status: {
+    exchange_partner_tech_name: string;
+    operational_state: string;
+    is_trading_halted: boolean;
+    message: unknown;
+    current_status: unknown;
+    upcoming_maintenance: unknown;
+    last_changed_at: string;
+    last_checked_at: string;
+  };
+};
+export type PerpOrdersPage = {
+  orders: PerpOrder[];
+  next_cursor: unknown;
+  /** `sort_ts` of the last order on the page, `null` on an empty page. */
+  last_sort_ts: string | null;
+};
+export type PerpPositionStatus = 'open' | 'closed';
+export type PerpOrderStatus = 'pending' | 'processing' | 'processed' | 'filled' | 'partially_filled' | 'failed' | 'canceled';
+type PerpPositionCore = {
+  contract_id: number;
+  contract_name: string;
+  contract_base_asset: string;
+  contract_quote_asset: string;
+  /** Seen: `long`, `short`. */
+  side: string;
+  /** Seen: `closed`. */
+  status: string;
+  leverage: number;
+  /** Seen: `isolated`. */
+  margin_type: string;
+  value_base: string;
+  margin_quote: string;
+  avg_entry_price: string;
+  liquidation_price: string;
+  funding_paid_quote: string;
+  created_at: string;
+  updated_at: string;
+  synced_at: string;
+};
+export type PerpPosition = PerpPositionCore & {
+  trading_agent_code: string;
+  /** Priced at the current mark, closed positions included, so it is not the P/L a closed position realised. */
+  valuation: {
+    server_time: string;
+    status: string;
+    mark_price: string;
+    index_price: string;
+    source_timestamp: string;
+    expires_at: string;
+    unrealized_pnl_quote: string;
+    equity_quote: string;
+  };
+  auto_close: unknown;
+};
+export type PerpOrder = {
+  order_id: string;
+  contract_id: number;
+  contract_name: string;
+  contract_base_asset: string;
+  contract_quote_asset: string;
+  side: string;
+  /** Seen: `market`. */
+  type: string;
+  /** Seen: `open`, `close`, `stop_loss`, `take_profit`. */
+  category: string;
+  status: string;
+  error_code: unknown;
+  leverage: number;
+  base_size: string;
+  base_price: string;
+  accounting_base_amount: string;
+  accounting_quote_amount: string;
+  filled_price: string | null;
+  filled_base_amount: string | null;
+  filled_quote_amount: string | null;
+  pnl_quote: string | null;
+  pnl_quote_charged: unknown;
+  roi: string | null;
+  trigger_price_quote: string | null;
+  limit_price_quote: string | null;
+  /** Unix seconds. */
+  valid_to: number | null;
+  liquidation_fee: unknown;
+  liquidation_fee_charged: unknown;
+  integrator_fee: string | null;
+  integrator_fee_charged: string | null;
+  venue_fee: string | null;
+  total_fee: string | null;
+  total_fee_charged: string | null;
+  margin_returned_amount: string | null;
+  created_at: string;
+  updated_at: string;
+  filled_at: string | null;
+  canceled_at: unknown;
+  sort_ts: string;
+  position: PerpPositionCore & {
+    fee_quote: unknown;
+    close_price: string;
+  };
+};
+export {};

package/build/api/perps.js

@@ -0,0 +1 @@
+export {};

package/build/bin/quiet-localstorage.js

@@ -0,0 +1,8 @@
+// source/bin/quiet-localstorage.ts
+const nodeOptions = (process.env["NODE_OPTIONS"] ?? "").split(/\s+/);
+if (![...process.execArgv, ...nodeOptions].some((arg) => arg.startsWith("--localstorage-file"))) Object.defineProperty(globalThis, "localStorage", {
+	value: void 0,
+	configurable: true,
+	writable: true
+});
+export {};

package/build/bin/walt.d.ts

@@ -0,0 +1 @@
+export {}

package/build/bin/walt.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import "./quiet-localstorage.js";
+import { COMMANDS, UsageError, run } from "../cli/run.js";
+import { WaltClient } from "../client.js";
+import { TelegramTokenSource } from "../telegram/auth.js";
+import { WaltAuthError, WaltRequestError } from "../transport.js";
+import { TelegramClient } from "teleproto";
+import { StringSession } from "teleproto/sessions/index.js";
+import { readFileSync } from "node:fs";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+// source/bin/walt.ts
+/**
+* Signs in to Telegram interactively and prints the session string to save as `TG_SESSION`.
+*
+* @returns The process exit code.
+*/
+const login = async () => {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	const ask = (question) => rl.question(question);
+	const apiId = Number(process.env["TG_API_ID"] || await ask("API id (from https://my.telegram.org): "));
+	if (!Number.isSafeInteger(apiId) || apiId <= 0) {
+		rl.close();
+		console.error("The API id must be the number shown at https://my.telegram.org");
+		return 1;
+	}
+	const apiHash = process.env["TG_API_HASH"] || await ask("API hash: ");
+	const client = new TelegramClient(new StringSession(""), apiId, apiHash, { connectionRetries: 3 });
+	await client.start({
+		phoneNumber: () => ask("Phone (+country...): "),
+		phoneCode: () => ask("Code you received: "),
+		password: () => ask("2FA password (blank if none): "),
+		onError: (error) => console.error(error)
+	});
+	rl.close();
+	console.log("\nLogged in. Save this as TG_SESSION (keep it secret):\n");
+	console.log(client.session.save());
+	await client.disconnect();
+	return 0;
+};
+const USAGE = `Usage: walt <command> [options]
+
+${COMMANDS}
+  login                     sign in to Telegram and print TG_SESSION
+
+Options:
+  --json                    print JSON instead of a table
+  --fiat CODE               currency for values (default USD)
+  --env-file PATH           read TG_API_ID, TG_API_HASH and TG_SESSION from a file
+  -h, --help                show this help
+  -v, --version             show the version
+
+Needs TG_API_ID and TG_API_HASH from https://my.telegram.org and TG_SESSION from \`walt login\`.
+Every command is read-only.`;
+const fail = (message, code) => {
+	console.error(`walt: ${message}`);
+	process.exit(code);
+};
+const parse = () => {
+	try {
+		return parseArgs({
+			allowPositionals: true,
+			options: {
+				json: { type: "boolean" },
+				fiat: { type: "string" },
+				"env-file": { type: "string" },
+				asset: { type: "string" },
+				limit: { type: "string" },
+				from: { type: "string" },
+				monthly: { type: "boolean" },
+				all: { type: "boolean" },
+				closed: { type: "boolean" },
+				help: {
+					type: "boolean",
+					short: "h"
+				},
+				version: {
+					type: "boolean",
+					short: "v"
+				}
+			}
+		});
+	} catch (error) {
+		return fail(`${error.message}\nRun \`walt --help\` for usage.`, 2);
+	}
+};
+const { values, positionals } = parse();
+const [command, ...args] = positionals;
+if (values.version) {
+	const manifest = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+	console.log(manifest.version);
+	process.exit(0);
+}
+if (values.help || command === void 0) {
+	console.log(USAGE);
+	process.exit(command === void 0 && !values.help ? 2 : 0);
+}
+if (values["env-file"] !== void 0) try {
+	process.loadEnvFile(values["env-file"]);
+} catch (error) {
+	fail(`cannot read ${values["env-file"]}: ${error.message}`, 2);
+}
+if (command === "login") process.exit(await login());
+const session = process.env["TG_SESSION"];
+const apiId = Number(process.env["TG_API_ID"]);
+const apiHash = process.env["TG_API_HASH"];
+if (!session || !apiId || !apiHash) fail("set TG_API_ID, TG_API_HASH and TG_SESSION first (run `walt login` for the session)", 2);
+const source = new TelegramTokenSource({
+	session: session ?? "",
+	apiId,
+	apiHash: apiHash ?? ""
+});
+const client = new WaltClient({ tokenProvider: (rejected) => source.token(rejected) });
+let exitCode = 0;
+try {
+	console.log(await run(client, command, args, values));
+} catch (error) {
+	if (error instanceof UsageError) {
+		console.error(`walt: ${error.message}\nRun \`walt --help\` for usage.`);
+		exitCode = 2;
+	} else if (error instanceof WaltRequestError) {
+		const code = error.body?.code;
+		console.error(`walt: ${error.message}${typeof code === "string" ? ` (${code})` : ""}`);
+		exitCode = 1;
+	} else if (error instanceof WaltAuthError) {
+		console.error(`walt: sign-in failed: ${error.message}`);
+		exitCode = 1;
+	} else {
+		console.error(`walt: ${error instanceof Error ? error.message : String(error)}`);
+		exitCode = 1;
+	}
+} finally {
+	await source.disconnect();
+}
+process.exit(exitCode);
+export {};

package/build/cli/run.d.ts

@@ -0,0 +1,22 @@
+import { WaltClient } from "../client.js";
+export type CliOptions = {
+  json?: boolean;
+  fiat?: string;
+  asset?: string;
+  limit?: string;
+  from?: string;
+  monthly?: boolean;
+  all?: boolean;
+  closed?: boolean;
+};
+export declare class UsageError extends Error {}
+export declare const COMMANDS = "Commands:\n  balances                  every asset: spot, staked and held by limit orders\n  history [--monthly]       balance, deposits, withdrawals and P/L per day or month\n          [--from DATE]     start date, YYYY-MM-DD (default: 30 days or 12 months back)\n  transactions              latest transactions\n          [--asset SYM]     only this asset\n          [--limit N]       how many (default 20)\n  price SYM...              current price and change over 24h, 7d and 30d\n  quote FROM TO AMOUNT      what an exchange would give right now, without making it\n  orders [--all]            open limit orders, or every order with --all\n  perps [--closed]          open perpetual positions, or closed ones\n  earn [--all]              your earn stakes, or every active campaign with --all";
+/**
+ * Runs one read-only command and returns what to print.
+ *
+ * @param client - A signed-in client.
+ * @param command - The command name, such as `balances`.
+ * @param args - Positional arguments after the command.
+ * @param options - Parsed flags.
+ */
+export declare const run: (client: WaltClient, command: string, args: string[], options?: CliOptions) => Promise<string>;

package/build/cli/run.js

@@ -0,0 +1,507 @@
+import { WaltRequestError } from "../transport.js";
+// source/cli/run.ts
+var UsageError = class extends Error {};
+const COMMANDS = `Commands:
+  balances                  every asset: spot, staked and held by limit orders
+  history [--monthly]       balance, deposits, withdrawals and P/L per day or month
+          [--from DATE]     start date, YYYY-MM-DD (default: 30 days or 12 months back)
+  transactions              latest transactions
+          [--asset SYM]     only this asset
+          [--limit N]       how many (default 20)
+  price SYM...              current price and change over 24h, 7d and 30d
+  quote FROM TO AMOUNT      what an exchange would give right now, without making it
+  orders [--all]            open limit orders, or every order with --all
+  perps [--closed]          open perpetual positions, or closed ones
+  earn [--all]              your earn stakes, or every active campaign with --all`;
+const fixed = (value, digits = 2) => {
+	const parsed = Number(value);
+	return value === null || value === void 0 || value === "" || !Number.isFinite(parsed) ? "-" : parsed.toFixed(digits);
+};
+const trimmed = (value) => {
+	const parsed = Number(value);
+	if (value === null || value === void 0 || value === "" || !Number.isFinite(parsed)) return "-";
+	return String(Number(parsed.toFixed(8)));
+};
+const significant = (value) => String(Number(value.toPrecision(8)));
+const percent = (value) => Number.isFinite(value) ? `${value >= 0 ? "+" : ""}${(value * 100).toFixed(2)}%` : "-";
+const change = (now, then) => then === void 0 || then === 0 ? "-" : percent(now / then - 1);
+const minute = (timestamp) => timestamp.slice(0, 16).replace("T", " ");
+const isoDate = (date) => date.toISOString().slice(0, 10);
+const ACCOUNT_KINDS = {
+	REGULAR: "spot",
+	EARN_V2: "earn",
+	HOLD_LIMIT: "orders"
+};
+const positiveInteger = (value, fallback) => {
+	if (value === void 0) return fallback;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) throw new UsageError(`--limit must be a whole number, got ${value}`);
+	return parsed;
+};
+const balances = async (client, fiat) => {
+	const data = await client.balances(fiat);
+	const total = Number(data.overall_available_balance_fiat_amount);
+	const rows = data.accounts.filter((account) => Number(account.total_balance) > 0).map((account) => ({
+		account,
+		value: Number(account.available_balance_fiat_amount)
+	})).sort((a, b) => b.value - a.value).map(({ account, value }) => ({
+		asset: account.currency,
+		kind: ACCOUNT_KINDS[account.account_type] ?? account.account_type.toLowerCase(),
+		amount: trimmed(account.total_balance),
+		value: value.toFixed(2),
+		share: total > 0 ? `${(value / total * 100).toFixed(1)}%` : "-"
+	}));
+	return {
+		columns: [
+			{
+				key: "asset",
+				title: "ASSET"
+			},
+			{
+				key: "kind",
+				title: "KIND"
+			},
+			{
+				key: "amount",
+				title: "AMOUNT",
+				numeric: true
+			},
+			{
+				key: "value",
+				title: `VALUE ${data.fiat_currency}`,
+				numeric: true
+			},
+			{
+				key: "share",
+				title: "SHARE",
+				numeric: true
+			}
+		],
+		rows,
+		footer: [`total ${total.toFixed(2)} ${data.fiat_currency}`]
+	};
+};
+const history = async (client, options) => {
+	const start = /* @__PURE__ */ new Date();
+	if (options.monthly) start.setUTCMonth(start.getUTCMonth() - 11, 1);
+	else start.setUTCDate(start.getUTCDate() - 29);
+	const from = options.from ?? isoDate(start);
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(from)) throw new UsageError(`--from must be YYYY-MM-DD, got ${from}`);
+	const data = await client.portfolioHistory(from, options.monthly ? "1m" : "1d");
+	const period = (dateFrom) => options.monthly ? dateFrom.slice(0, 7) : dateFrom.slice(0, 10);
+	const rows = data.chart.data_points.map((point) => ({
+		period: period(point.date_from),
+		balance: fixed(point.close_amount_fiat),
+		deposits: fixed(point.deposits_details.total),
+		withdrawals: fixed(point.withdrawals_details.total),
+		pnl: fixed(point.total_pnl),
+		pnlPercent: point.total_pnl_percent === null ? "-" : `${fixed(point.total_pnl_percent)}%`
+	}));
+	const total = data.total_period_details;
+	return {
+		columns: [
+			{
+				key: "period",
+				title: options.monthly ? "MONTH" : "DAY"
+			},
+			{
+				key: "balance",
+				title: `BALANCE ${data.fiat_currency}`,
+				numeric: true
+			},
+			{
+				key: "deposits",
+				title: "DEPOSITS",
+				numeric: true
+			},
+			{
+				key: "withdrawals",
+				title: "WITHDRAWALS",
+				numeric: true
+			},
+			{
+				key: "pnl",
+				title: "P/L",
+				numeric: true
+			},
+			{
+				key: "pnlPercent",
+				title: "P/L %",
+				numeric: true
+			}
+		],
+		rows,
+		footer: [`since ${from}: P/L ${fixed(total.total_pnl)} ${data.fiat_currency}` + (total.total_pnl_percent === null ? "" : ` (${fixed(total.total_pnl_percent)}%)`) + `, deposits ${fixed(total.deposits_details.total)}, withdrawals ${fixed(total.withdrawals_details.total)}`, "as reported by Walt"]
+	};
+};
+const transactions = async (client, options) => {
+	const limit = positiveInteger(options.limit, 20);
+	return {
+		columns: [
+			{
+				key: "time",
+				title: "TIME (UTC)"
+			},
+			{
+				key: "type",
+				title: "TYPE"
+			},
+			{
+				key: "gateway",
+				title: "VIA"
+			},
+			{
+				key: "amount",
+				title: "AMOUNT",
+				numeric: true
+			},
+			{
+				key: "asset",
+				title: "ASSET"
+			},
+			{
+				key: "status",
+				title: "STATUS"
+			}
+		],
+		rows: (options.asset ? await client.accountTransactions(options.asset, limit) : await client.transactions(limit)).transactions.map((row) => ({
+			time: minute(row.created_at),
+			type: row.type,
+			gateway: row.gateway,
+			amount: row.amount,
+			asset: row.currency,
+			status: row.status
+		}))
+	};
+};
+const price = async (client, symbols, fiat) => {
+	if (symbols.length === 0) throw new UsageError("price needs at least one symbol, such as `walt price BTC`");
+	const rows = await Promise.all(symbols.map(async (symbol) => {
+		const charts = await client.charts(symbol, fiat);
+		const rates = (points) => points.map((point) => Number(point.rate));
+		const day = rates(charts.day);
+		const last = day.at(-1) ?? rates(charts.month).at(-1);
+		if (last === void 0) return {
+			asset: symbol,
+			price: "-",
+			day: "-",
+			week: "-",
+			month: "-"
+		};
+		return {
+			asset: symbol,
+			price: significant(last),
+			day: change(last, day[0]),
+			week: change(last, rates(charts.week)[0]),
+			month: change(last, rates(charts.month)[0])
+		};
+	}));
+	return {
+		columns: [
+			{
+				key: "asset",
+				title: "ASSET"
+			},
+			{
+				key: "price",
+				title: `PRICE ${fiat}`,
+				numeric: true
+			},
+			{
+				key: "day",
+				title: "24H",
+				numeric: true
+			},
+			{
+				key: "week",
+				title: "7D",
+				numeric: true
+			},
+			{
+				key: "month",
+				title: "30D",
+				numeric: true
+			}
+		],
+		rows
+	};
+};
+const quoteSizes = (amount) => {
+	const [whole = "", fraction = ""] = amount.split(".");
+	const sizes = [amount, ...[
+		6,
+		4,
+		2,
+		0
+	].filter((places) => places < fraction.length).map((places) => places === 0 ? whole : `${whole}.${fraction.slice(0, places)}`)];
+	return [...new Set(sizes)].filter((size) => Number(size) > 0);
+};
+const quote = async (client, args) => {
+	const [from, to, amount] = args;
+	if (!from || !to || amount === void 0 || !/^\d+(\.\d+)?$/.test(amount) || !(Number(amount) > 0)) throw new UsageError("usage: walt quote FROM TO AMOUNT, such as `walt quote USDT BTC 100`");
+	let result;
+	let size = amount;
+	let rejection;
+	for (const candidate of quoteSizes(amount)) try {
+		result = await client.quote(from, to, Number(candidate));
+		size = candidate;
+		break;
+	} catch (error) {
+		if (!(error instanceof WaltRequestError) || error.body?.code !== "invalid_amount") throw error;
+		rejection = error;
+	}
+	if (result === void 0) throw rejection;
+	const sale = result.to_currency === "USDT" && result.from_currency !== "USDT";
+	const price = result.from_amount <= 0 || result.to_amount <= 0 ? "-" : sale ? `${significant(result.to_amount / result.from_amount)} USDT/${result.from_currency}` : `${significant(result.from_amount / result.to_amount)} ${result.from_currency}/${result.to_currency}`;
+	const footer = [`order size ${result.min_amount} to ${result.max_amount} ${from}`, "fees included, nothing was exchanged"];
+	if (size !== amount) footer.unshift(`amount cut to ${size} ${from}, the most decimals it accepts`);
+	return {
+		columns: [
+			{
+				key: "pay",
+				title: "PAY",
+				numeric: true
+			},
+			{
+				key: "receive",
+				title: "RECEIVE",
+				numeric: true
+			},
+			{
+				key: "price",
+				title: "PRICE",
+				numeric: true
+			}
+		],
+		rows: [{
+			pay: `${result.from_amount} ${result.from_currency}`,
+			receive: `${result.to_amount} ${result.to_currency}`,
+			price
+		}],
+		footer
+	};
+};
+const orders = async (client, options) => {
+	const list = await client.limitOrders(options.all ? { limit: 100 } : {
+		status: ["OPEN", "CANCELLING"],
+		limit: 100
+	});
+	const held = list.filter((order) => order.status === "OPEN").reduce((sum, order) => sum + Number(order.total), 0);
+	return {
+		columns: [
+			{
+				key: "created",
+				title: "CREATED (UTC)"
+			},
+			{
+				key: "asset",
+				title: "ASSET"
+			},
+			{
+				key: "side",
+				title: "SIDE"
+			},
+			{
+				key: "limit",
+				title: "LIMIT",
+				numeric: true
+			},
+			{
+				key: "quantity",
+				title: "QUANTITY",
+				numeric: true
+			},
+			{
+				key: "total",
+				title: "TOTAL",
+				numeric: true
+			},
+			{
+				key: "fee",
+				title: "FEE",
+				numeric: true
+			},
+			{
+				key: "status",
+				title: "STATUS"
+			}
+		],
+		rows: list.map((order) => ({
+			created: minute(order.created_at),
+			asset: order.base_currency,
+			side: order.side,
+			limit: order.price_limit,
+			quantity: order.quantity,
+			total: `${order.total} ${order.fee_currency}`,
+			fee: order.fee,
+			status: order.status
+		})),
+		footer: [`${held.toFixed(2)} held by open orders`]
+	};
+};
+const perps = async (client, options) => {
+	const positions = await client.perpPositions({ statuses: [options.closed ? "closed" : "open"] });
+	const columns = [
+		{
+			key: "contract",
+			title: "CONTRACT"
+		},
+		{
+			key: "side",
+			title: "SIDE"
+		},
+		{
+			key: "leverage",
+			title: "LEV",
+			numeric: true
+		},
+		{
+			key: "size",
+			title: "SIZE",
+			numeric: true
+		},
+		{
+			key: "entry",
+			title: "ENTRY",
+			numeric: true
+		},
+		{
+			key: "margin",
+			title: "MARGIN",
+			numeric: true
+		}
+	];
+	if (options.closed) columns.push({
+		key: "opened",
+		title: "OPENED (UTC)"
+	}, {
+		key: "closed",
+		title: "CLOSED (UTC)"
+	});
+	else columns.push({
+		key: "mark",
+		title: "MARK",
+		numeric: true
+	}, {
+		key: "liquidation",
+		title: "LIQUIDATION",
+		numeric: true
+	}, {
+		key: "pnl",
+		title: "UNREALISED",
+		numeric: true
+	});
+	return {
+		columns,
+		rows: positions.map((position) => ({
+			contract: position.contract_name,
+			side: position.side,
+			leverage: `${position.leverage}x`,
+			size: position.value_base,
+			entry: position.avg_entry_price,
+			margin: fixed(position.margin_quote),
+			opened: minute(position.created_at),
+			closed: minute(position.updated_at),
+			mark: position.valuation.mark_price,
+			liquidation: fixed(position.liquidation_price, 4),
+			pnl: fixed(position.valuation.unrealized_pnl_quote)
+		}))
+	};
+};
+const earn = async (client, options) => {
+	const { campaigns } = await client.earnCampaigns();
+	return {
+		columns: [
+			{
+				key: "campaign",
+				title: "CAMPAIGN"
+			},
+			{
+				key: "asset",
+				title: "ASSET"
+			},
+			{
+				key: "staked",
+				title: "STAKED",
+				numeric: true
+			},
+			{
+				key: "paid",
+				title: "PAID OUT",
+				numeric: true
+			},
+			{
+				key: "apy",
+				title: "APY",
+				numeric: true
+			},
+			{
+				key: "status",
+				title: "STATUS"
+			}
+		],
+		rows: campaigns.filter((campaign) => options.all ? campaign.status === "active" : campaign.account !== null && Number(campaign.account.balance) > 0).map((campaign) => ({
+			campaign: campaign.name,
+			asset: campaign.account?.currency ?? campaign.deposit_currency,
+			staked: trimmed(campaign.account?.balance),
+			paid: trimmed(campaign.account?.paid_out_amount),
+			apy: `${fixed(Number(campaign.current_apy) * 100)}%`,
+			status: campaign.status
+		}))
+	};
+};
+const render = (report) => {
+	if (report.rows.length === 0) return ["nothing to show", ...report.footer ?? []].join("\n");
+	const widths = report.columns.map((column) => Math.max(column.title.length, ...report.rows.map((row) => (row[column.key] ?? "").length)));
+	const line = (cells) => cells.map((cell, index) => {
+		const width = widths[index] ?? 0;
+		return report.columns[index]?.numeric ? cell.padStart(width) : cell.padEnd(width);
+	}).join("  ").trimEnd();
+	return [
+		line(report.columns.map((column) => column.title)),
+		...report.rows.map((row) => line(report.columns.map((column) => row[column.key] ?? ""))),
+		...report.footer ?? []
+	].join("\n");
+};
+/**
+* Runs one read-only command and returns what to print.
+*
+* @param client - A signed-in client.
+* @param command - The command name, such as `balances`.
+* @param args - Positional arguments after the command.
+* @param options - Parsed flags.
+*/
+const run = async (client, command, args, options = {}) => {
+	const fiat = (options.fiat ?? "USD").toUpperCase();
+	let report;
+	switch (command) {
+		case "balances":
+			report = await balances(client, fiat);
+			break;
+		case "history":
+			report = await history(client, options);
+			break;
+		case "transactions":
+			report = await transactions(client, options);
+			break;
+		case "price":
+			report = await price(client, args, fiat);
+			break;
+		case "quote":
+			report = await quote(client, args);
+			break;
+		case "orders":
+			report = await orders(client, options);
+			break;
+		case "perps":
+			report = await perps(client, options);
+			break;
+		case "earn":
+			report = await earn(client, options);
+			break;
+		default: throw new UsageError(`unknown command: ${command}`);
+	}
+	if (!options.json) return render(report);
+	return JSON.stringify(report.rows.map((row) => Object.fromEntries(report.columns.map((column) => [column.key, row[column.key] ?? null]))), null, 2);
+};
+export { COMMANDS, UsageError, run };

package/build/client.d.ts

@@ -1,8 +1,11 @@
 import { AccountsResponse, Charts, Coin, CoinDetails, FiatCurrency, PriceAtTime } from "./api/accounts.js";
 import { PnlResponse, PortfolioHistory } from "./api/analytics.js";
+import { Balances } from "./api/balances.js";
+import { CandleRequest, CandleSeries } from "./api/candles.js";
 import { EarnCampaignsResponse, EarnRate, EarnTransaction, EarnTransactionsPage } from "./api/earn.js";
 import { AvailableExchanges, Exchange, ExchangeQuote, ExchangeRequest } from "./api/exchange.js";
 import { LimitOrder, LimitOrderBounds, LimitOrderQuote, LimitOrderToken } from "./api/limit-orders.js";
+import { PerpContract, PerpOrderStatus, PerpOrdersPage, PerpPosition, PerpPositionStatus, PerpSystemStatus } from "./api/perps.js";
 import { Transaction, TransactionDetails, TransactionGateway, TransactionsPage } from "./api/transactions.js";
 export type WaltClientOptions = {
   /** Called again with the rejected token after a 401, so the provider can renew it before its expiry. */
@@ -36,6 +39,12 @@ export declare class WaltClient {
   private readonly maxConcurrent;
   constructor(options: WaltClientOptions);
   accounts(): Promise<AccountsResponse>;
+  /**
+   * Every balance with its account type, including USDT held by open limit orders, which `accounts()` omits.
+   *
+   * @param fiatCurrency - Currency of the fiat amounts and the overall total.
+   */
+  balances(fiatCurrency: FiatCurrency): Promise<Balances>;
   coins(fiatCurrency: FiatCurrency): Promise<Coin[]>;
   localCurrency(): Promise<FiatCurrency>;
   transactions(limit?: number, cursor?: string): Promise<TransactionsPage>;
@@ -115,6 +124,35 @@ export declare class WaltClient {
   limitOrderBounds(baseCurrency: string): Promise<LimitOrderBounds>;
   /** Every currency a limit order can buy. */
   limitOrderTokens(): Promise<LimitOrderToken[]>;
+  /** @param contractId - Only this contract. */
+  perpContracts(contractId?: number): Promise<PerpContract[]>;
+  perpSystemStatus(): Promise<PerpSystemStatus>;
+  /**
+   * @param options - Filters, all optional.
+   * @param options.statuses - Only positions in these states. Without it, closed positions are included.
+   * @param options.contractId - Only this contract.
+   */
+  perpPositions(options?: {
+    statuses?: PerpPositionStatus[];
+    contractId?: number;
+  }): Promise<PerpPosition[]>;
+  /**
+   * @param options - Filters, all optional.
+   * @param options.contractId - Only this contract.
+   * @param options.statuses - Only orders in these states.
+   * @param options.limit - Most orders to return.
+   */
+  perpOrders(options?: {
+    contractId?: number;
+    statuses?: PerpOrderStatus[];
+    limit?: number;
+  }): Promise<PerpOrdersPage>;
+  /**
+   * OHLCV candles for several tickers in one request.
+   *
+   * @param requests - One per series wanted.
+   */
+  candles(requests: CandleRequest[]): Promise<CandleSeries[]>;
   coinDetails(currency: string, fiatCurrency: FiatCurrency): Promise<CoinDetails>;
   charts(currency: string, fiatCurrency: FiatCurrency): Promise<Charts>;
   priceForFiatAtTime(cryptoCurrency: string, localCurrency: FiatCurrency, amount: number | string, time: Date | string | number): Promise<PriceAtTime>;

package/build/client.js

@@ -32,6 +32,16 @@ var WaltClient = class {
 	accounts() {
 		return this.transport.get("/api/v1/accounts/");
 	}
+	/**
+	* Every balance with its account type, including USDT held by open limit orders, which `accounts()` omits.
+	*
+	* @param fiatCurrency - Currency of the fiat amounts and the overall total.
+	*/
+	async balances(fiatCurrency) {
+		const query = new URLSearchParams({ fiat_currency: fiatCurrency });
+		const { data } = await this.transport.get(`/portmone/public-api/v1/user/accounts?${query.toString()}`);
+		return data;
+	}
 	async coins(fiatCurrency) {
 		const { coins } = await this.transport.get(`/api/v1/coins/list/${fiatCurrency}/`);
 		return coins;
@@ -222,6 +232,51 @@ var WaltClient = class {
 		const { tokens } = await this.transport.get("/emporos/public-api/orders/limit/tokens");
 		return tokens;
 	}
+	/** @param contractId - Only this contract. */
+	async perpContracts(contractId) {
+		const query = contractId === void 0 ? "" : `?${new URLSearchParams({ contract_id: String(contractId) }).toString()}`;
+		const { contracts } = await this.transport.get(`/perps/public-api/v1/contracts/${query}`);
+		return contracts;
+	}
+	perpSystemStatus() {
+		return this.transport.get("/perps/public-api/v1/system-status/");
+	}
+	/**
+	* @param options - Filters, all optional.
+	* @param options.statuses - Only positions in these states. Without it, closed positions are included.
+	* @param options.contractId - Only this contract.
+	*/
+	async perpPositions(options = {}) {
+		const query = new URLSearchParams();
+		if (options.contractId !== void 0) query.set("contract_id", String(options.contractId));
+		for (const status of options.statuses ?? []) query.append("statuses", status);
+		const search = query.size === 0 ? "" : `?${query.toString()}`;
+		const { positions } = await this.transport.get(`/perps/public-api/v1/positions/${search}`);
+		return positions;
+	}
+	/**
+	* @param options - Filters, all optional.
+	* @param options.contractId - Only this contract.
+	* @param options.statuses - Only orders in these states.
+	* @param options.limit - Most orders to return.
+	*/
+	perpOrders(options = {}) {
+		const query = new URLSearchParams();
+		if (options.contractId !== void 0) query.set("contract_id", String(options.contractId));
+		if (options.limit !== void 0) query.set("limit", String(options.limit));
+		for (const status of options.statuses ?? []) query.append("statuses", status);
+		const search = query.size === 0 ? "" : `?${query.toString()}`;
+		return this.transport.get(`/perps/public-api/v2/orders/${search}`);
+	}
+	/**
+	* OHLCV candles for several tickers in one request.
+	*
+	* @param requests - One per series wanted.
+	*/
+	async candles(requests) {
+		const { responses } = await this.transport.post("/kandelabr/public-api/v1/candles/batch", { requests });
+		return responses;
+	}
 	coinDetails(currency, fiatCurrency) {
 		return this.transport.get(`/api/v1/coins/details/${encodeURIComponent(currency)}/${encodeURIComponent(fiatCurrency)}/`);
 	}

package/build/index.d.ts

@@ -1,10 +1,13 @@
 import { Account, AccountAction, AccountActions, AccountAddress, AccountsResponse, ChartPoint, Charts, Coin, CoinDetails, FiatCurrency, PriceAtTime, TradingHoursPeriod, TradingHoursState } from "./api/accounts.js";
 import { PnlPosition, PnlResponse, PnlTotals, PortfolioFlows, PortfolioHistory, PortfolioPeriod } from "./api/analytics.js";
+import { Balance, Balances } from "./api/balances.js";
+import { Candle, CandleRequest, CandleSeries } from "./api/candles.js";
 import { EarnAccessPolicy, EarnAccount, EarnAmount, EarnBonus, EarnCampaign, EarnCampaignsResponse, EarnDepegInfo, EarnInterestRate, EarnPayoutPool, EarnRate, EarnTransaction, EarnTransactionsPage } from "./api/earn.js";
 import { AvailableExchanges, Exchange, ExchangeQuote, ExchangeRequest } from "./api/exchange.js";
 import { LimitOrder, LimitOrderBounds, LimitOrderQuote, LimitOrderToken } from "./api/limit-orders.js";
+import { PerpContract, PerpOrder, PerpOrderStatus, PerpOrdersPage, PerpPosition, PerpPositionStatus, PerpSystemStatus } from "./api/perps.js";
 import { NormalizedTransaction, Transaction, TransactionDetails, TransactionGateway, TransactionLeg, TransactionsPage, normalizeTransaction } from "./api/transactions.js";
 import { Portfolio, PortfolioEntry, WaltClient, WaltClientOptions } from "./client.js";
 import { TelegramTokenSource, TelegramTokenSourceOptions, TokenState, TokenStorage } from "./telegram/auth.js";
 import { WaltAuthError, WaltRequestError } from "./transport.js";
-export { type Account, type AccountAction, type AccountActions, type AccountAddress, type AccountsResponse, type AvailableExchanges, type ChartPoint, type Charts, type Coin, type CoinDetails, type EarnAccessPolicy, type EarnAccount, type EarnAmount, type EarnBonus, type EarnCampaign, type EarnCampaignsResponse, type EarnDepegInfo, type EarnInterestRate, type EarnPayoutPool, type EarnRate, type EarnTransaction, type EarnTransactionsPage, type Exchange, type ExchangeQuote, type ExchangeRequest, type FiatCurrency, type LimitOrder, type LimitOrderBounds, type LimitOrderQuote, type LimitOrderToken, type NormalizedTransaction, type PnlPosition, type PnlResponse, type PnlTotals, type Portfolio, type PortfolioEntry, type PortfolioFlows, type PortfolioHistory, type PortfolioPeriod, type PriceAtTime, TelegramTokenSource, type TelegramTokenSourceOptions, type TokenState, type TokenStorage, type TradingHoursPeriod, type TradingHoursState, type Transaction, type TransactionDetails, type TransactionGateway, type TransactionLeg, type TransactionsPage, WaltAuthError, WaltClient, type WaltClientOptions, WaltRequestError, normalizeTransaction };
+export { type Account, type AccountAction, type AccountActions, type AccountAddress, type AccountsResponse, type AvailableExchanges, type Balance, type Balances, type Candle, type CandleRequest, type CandleSeries, type ChartPoint, type Charts, type Coin, type CoinDetails, type EarnAccessPolicy, type EarnAccount, type EarnAmount, type EarnBonus, type EarnCampaign, type EarnCampaignsResponse, type EarnDepegInfo, type EarnInterestRate, type EarnPayoutPool, type EarnRate, type EarnTransaction, type EarnTransactionsPage, type Exchange, type ExchangeQuote, type ExchangeRequest, type FiatCurrency, type LimitOrder, type LimitOrderBounds, type LimitOrderQuote, type LimitOrderToken, type NormalizedTransaction, type PerpContract, type PerpOrder, type PerpOrderStatus, type PerpOrdersPage, type PerpPosition, type PerpPositionStatus, type PerpSystemStatus, type PnlPosition, type PnlResponse, type PnlTotals, type Portfolio, type PortfolioEntry, type PortfolioFlows, type PortfolioHistory, type PortfolioPeriod, type PriceAtTime, TelegramTokenSource, type TelegramTokenSourceOptions, type TokenState, type TokenStorage, type TradingHoursPeriod, type TradingHoursState, type Transaction, type TransactionDetails, type TransactionGateway, type TransactionLeg, type TransactionsPage, WaltAuthError, WaltClient, type WaltClientOptions, WaltRequestError, normalizeTransaction };

package/build/transport.js

@@ -23,6 +23,11 @@ const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
 	503,
 	504
 ]);
+const BEARER_SERVICES = [
+	"/emporos/",
+	"/portmone/",
+	"/kandelabr/"
+];
 const MAX_RETRY_DELAY_MS = 3e4;
 const hex = (bytes) => randomBytes(bytes).toString("hex");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -121,7 +126,7 @@ var Transport = class {
 		const headers = {
 			...BROWSER_HEADERS,
 			accept: "application/json",
-			authorization: path.startsWith("/emporos/") ? `Bearer ${jwt}` : jwt,
+			authorization: BEARER_SERVICES.some((prefix) => path.startsWith(prefix)) ? `Bearer ${jwt}` : jwt,
 			referer: `${this.baseUrl}/main?ep=menu${userId === null ? "" : `&tgWebAppUserId=${userId}`}`,
 			baggage: this.baggage,
 			"sentry-trace": `${this.traceId}-${hex(8)}-0`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2bad/walt",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Client for the Walt (ex. Wallet) API in Telegram to track a crypto portfolio and exchange between assets",
   "keywords": [
     "telegram",
@@ -36,7 +36,7 @@
     }
   },
   "bin": {
-    "telegram-login": "./build/bin/login.js"
+    "walt": "./build/bin/walt.js"
   },
   "files": [
     "build"
@@ -74,7 +74,7 @@
     "fix": "run-p fix:**",
     "fix:code": "oxlint --fix ./source",
     "fix:format": "oxfmt ./source ./examples",
-    "telegram:login": "node --env-file-if-exists=.env source/bin/login.ts",
+    "telegram:login": "run-s build && node --env-file-if-exists=.env build/bin/walt.js login",
     "example": "run-s build && node --env-file-if-exists=.env examples/portfolio.ts",
     "preversion": "run-s check test build",
     "test": "vitest run",

package/build/bin/login.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { TelegramClient } from "teleproto";
-import { StringSession } from "teleproto/sessions/index.js";
-import { createInterface } from "node:readline/promises";
-import { stdin, stdout } from "node:process";
-// source/bin/login.ts
-const rl = createInterface({
-	input: stdin,
-	output: stdout
-});
-const ask = (question) => rl.question(question);
-const apiId = Number(process.env["TG_API_ID"] || await ask("API id (from https://my.telegram.org): "));
-if (!Number.isSafeInteger(apiId) || apiId <= 0) {
-	console.error("The API id must be the number shown at https://my.telegram.org");
-	process.exit(1);
-}
-const apiHash = process.env["TG_API_HASH"] || await ask("API hash: ");
-const client = new TelegramClient(new StringSession(""), apiId, apiHash, { connectionRetries: 3 });
-await client.start({
-	phoneNumber: () => ask("Phone (+country...): "),
-	phoneCode: () => ask("Code you received: "),
-	password: () => ask("2FA password (blank if none): "),
-	onError: (error) => console.error(error)
-});
-rl.close();
-console.log("\nLogged in. Save this as TG_SESSION (keep it secret):\n");
-console.log(client.session.save());
-await client.disconnect();
-process.exit(0);
-export {};