@2bad/walt 1.0.1 → 2.1.0

package/build/cli/run.js

@@ -0,0 +1,510 @@
+import { WaltRequestError } from "../transport.js";
+// source/cli/run.ts
+var UsageError = class extends Error {};
+const COMMANDS = `Commands:
+  balances [--all]          every asset: spot, staked and held by limit orders,
+                            and with --all the ones worth less than 0.01
+  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) => Number.isFinite(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, options) => {
+	const data = await client.balances(fiat);
+	const total = Number(data.overall_available_balance_fiat_amount);
+	const held = data.accounts.filter((account) => Number(account.total_balance) > 0).map((account) => ({
+		account,
+		value: Number(account.available_balance_fiat_amount)
+	}));
+	const shown = options.all ? held : held.filter(({ value }) => !(value < .005));
+	const rows = shown.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}`, ...shown.length < held.length ? [`${held.length - shown.length} worth less than 0.01 not shown, --all lists them`] : []]
+	};
+};
+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: trimmed(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)} USDT 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: trimmed(position.value_base),
+			entry: significant(Number(position.avg_entry_price)),
+			margin: fixed(position.margin_quote),
+			opened: minute(position.created_at),
+			closed: minute(position.updated_at),
+			mark: significant(Number(position.valuation.mark_price)),
+			liquidation: significant(Number(position.liquidation_price)),
+			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, options);
+			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/core.d.ts

@@ -0,0 +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 { RefreshTokenSource, RefreshTokenSourceOptions, TokenState, TokenStorage } from "./refresh.js";
+import { WaltAuthError, WaltRequestError } from "./transport.js";
+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, RefreshTokenSource, type RefreshTokenSourceOptions, 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/core.js

@@ -0,0 +1,5 @@
+import { normalizeTransaction } from "./api/transactions.js";
+import { WaltClient } from "./client.js";
+import { RefreshTokenSource } from "./refresh.js";
+import { WaltAuthError, WaltRequestError } from "./transport.js";
+export { RefreshTokenSource, WaltAuthError, WaltClient, WaltRequestError, normalizeTransaction };

package/build/index.d.ts

@@ -1,10 +1,14 @@
 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 { RefreshTokenSource, RefreshTokenSourceOptions, TokenState, TokenStorage } from "./refresh.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 };
+import { TelegramTokenSource, TelegramTokenSourceOptions } from "./telegram/auth.js";
+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, RefreshTokenSource, type RefreshTokenSourceOptions, 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 };