@2bad/walt 0.0.0-stage → 1.0.0

package/build/bin/login.js

@@ -0,0 +1,26 @@
+#!/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): "));
+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 {};

package/build/browser.d.ts

@@ -0,0 +1,19 @@
+/** The headers every request from the Walt web app carries in Chrome on Windows, captured from real traffic. */
+export declare const BROWSER_HEADERS: {
+  'accept-encoding': string;
+  'accept-language': string;
+  'cache-control': string;
+  dnt: string;
+  pragma: string;
+  priority: string;
+  'sec-ch-ua': string;
+  'sec-ch-ua-mobile': string;
+  'sec-ch-ua-platform': string;
+  'sec-fetch-dest': string;
+  'sec-fetch-mode': string;
+  'sec-fetch-site': string;
+  'sec-gpc': string;
+  'user-agent': string;
+};
+export declare const SENTRY_RELEASE = "10.0.84666";
+export declare const SENTRY_PUBLIC_KEY = "544a92e441a24f17aa6b08e34e728ed2";

package/build/browser.js

@@ -0,0 +1,21 @@
+// source/browser.ts
+/** The headers every request from the Walt web app carries in Chrome on Windows, captured from real traffic. */
+const BROWSER_HEADERS = {
+	"accept-encoding": "gzip, deflate, br, zstd",
+	"accept-language": "en-US,en;q=0.9",
+	"cache-control": "no-cache",
+	dnt: "1",
+	pragma: "no-cache",
+	priority: "u=1, i",
+	"sec-ch-ua": "\"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"156\", \"Google Chrome\";v=\"156\"",
+	"sec-ch-ua-mobile": "?0",
+	"sec-ch-ua-platform": "\"Windows\"",
+	"sec-fetch-dest": "empty",
+	"sec-fetch-mode": "cors",
+	"sec-fetch-site": "same-origin",
+	"sec-gpc": "1",
+	"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36"
+};
+const SENTRY_RELEASE = "10.0.84666";
+const SENTRY_PUBLIC_KEY = "544a92e441a24f17aa6b08e34e728ed2";
+export { BROWSER_HEADERS, SENTRY_PUBLIC_KEY, SENTRY_RELEASE };

package/build/client.d.ts

@@ -0,0 +1,138 @@
+import { AccountsResponse, Charts, Coin, CoinDetails, FiatCurrency, PriceAtTime } from "./api/accounts.js";
+import { PnlResponse, PortfolioHistory } from "./api/analytics.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 { 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. */
+  tokenProvider: (rejected?: string) => Promise<string>;
+  baseUrl?: string;
+  fetch?: typeof fetch;
+  /** Extra attempts after a request fails on a transient status. Default 3, `0` disables retrying. */
+  retries?: number;
+  /** Base for the exponential backoff between those attempts, in ms. Default 500. */
+  retryDelayMs?: number;
+  /** Requests allowed in flight at once. Default 4, `Infinity` removes the limit. */
+  maxConcurrent?: number;
+};
+export type PortfolioEntry = {
+  currency: string;
+  amount: string;
+  fiatValue: number;
+};
+export type Portfolio = {
+  /** Spot balances above zero, largest fiat value first. */
+  entries: PortfolioEntry[];
+  entriesTotal: number;
+  /** The API's own total, which includes staked funds. */
+  total: number;
+  /** `total - entriesTotal`, itemised by `earnCampaigns()`. */
+  staked: number;
+  fiatCurrency: string;
+};
+export declare class WaltClient {
+  private readonly transport;
+  private readonly maxConcurrent;
+  constructor(options: WaltClientOptions);
+  accounts(): Promise<AccountsResponse>;
+  coins(fiatCurrency: FiatCurrency): Promise<Coin[]>;
+  localCurrency(): Promise<FiatCurrency>;
+  transactions(limit?: number, cursor?: string): Promise<TransactionsPage>;
+  accountTransactions(currency: string, limit?: number, cursor?: string): Promise<TransactionsPage>;
+  private walk;
+  allTransactions(limit?: number): AsyncGenerator<Transaction>;
+  allAccountTransactions(currency: string, limit?: number): AsyncGenerator<Transaction>;
+  /**
+   * `transactionDetails()` for each listing row, several in flight, yielded in input order.
+   * A lookup that still fails after its retries ends the iteration.
+   *
+   * @param transactions - Listing rows, typically `allTransactions()`.
+   * @yields One detail record per row.
+   */
+  detailsFor(transactions: AsyncIterable<Transaction> | Iterable<Transaction>): AsyncGenerator<TransactionDetails>;
+  /**
+   * @param id - Transaction id from a listing row.
+   * @param gateway - The row's `gateway`. Some records, such as `xstocks_dividends`, 404 without it.
+   */
+  transactionDetails(id: number | string, gateway?: TransactionGateway | (string & {})): Promise<TransactionDetails>;
+  unconfirmedTransactions<T = unknown>(limit?: number): Promise<{
+    transactions: T[];
+    size: number;
+  }>;
+  frozenBalances<T = unknown>(): Promise<T[]>;
+  /** Every earn campaign. Staked balances are here, not in `accounts()`. */
+  earnCampaigns(): Promise<EarnCampaignsResponse>;
+  /**
+   * Deposits, withdrawals and payouts within one campaign, newest first.
+   *
+   * @param campaignId - `campaign_id` from `earnCampaigns()`.
+   * @param limit - Rows per page. The API defaults to 10.
+   * @param after - The previous page, to fetch the one that follows it.
+   */
+  earnCampaignTransactions(campaignId: number | string, limit?: number, after?: EarnTransactionsPage): Promise<EarnTransactionsPage>;
+  /**
+   * Every row of `earnCampaignTransactions()`, page by page. The cursors stay set past the last row,
+   * so a page shorter than `limit` ends the walk.
+   *
+   * @param campaignId - `campaign_id` from `earnCampaigns()`.
+   * @param limit - Rows per page.
+   * @yields One row per deposit, withdrawal or payout.
+   */
+  allEarnCampaignTransactions(campaignId: number | string, limit?: number): AsyncGenerator<EarnTransaction>;
+  earnRate(from: string, to: string): Promise<EarnRate>;
+  pnl(): Promise<PnlResponse>;
+  /**
+   * Balance, P/L, deposits and withdrawals per day or per calendar month, plus totals for the whole range.
+   *
+   * @param dateFrom - Start of the first period, as a `Date` or `YYYY-MM-DD`. A `Date` counts by its UTC day.
+   * @param resolution - `1d` for days, `1m` for months.
+   */
+  portfolioHistory(dateFrom: Date | string, resolution: '1d' | '1m'): Promise<PortfolioHistory>;
+  /**
+   * @param options - Filters, all optional.
+   * @param options.status - Only orders in these states, such as `OPEN`.
+   * @param options.limit - Most orders to return.
+   */
+  limitOrders(options?: {
+    status?: string[];
+    limit?: number;
+  }): Promise<LimitOrder[]>;
+  limitOrder(id: string): Promise<LimitOrder>;
+  /**
+   * Fee and fill for a limit order, without placing it. Only `BUY` is accepted.
+   *
+   * @param baseCurrency - What is bought, from `limitOrderTokens()`.
+   * @param side - `SELL` is a valid value that the API currently rejects.
+   * @param priceLimit - Highest price to pay per unit.
+   * @param size - `amount` to spend, or `quantity` of `baseCurrency` to receive.
+   */
+  limitOrderQuote(baseCurrency: string, side: 'BUY' | 'SELL', priceLimit: number | string, size: {
+    amount: number | string;
+  } | {
+    quantity: number | string;
+  }): Promise<LimitOrderQuote>;
+  limitOrderBounds(baseCurrency: string): Promise<LimitOrderBounds>;
+  /** Every currency a limit order can buy. */
+  limitOrderTokens(): Promise<LimitOrderToken[]>;
+  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>;
+  availableExchanges(): Promise<AvailableExchanges>;
+  /**
+   * Executable rate, spread included, unlike the display rates.
+   *
+   * @param fromCurrency - What is paid.
+   * @param toCurrency - What is received.
+   * @param fromAmount - Amount of `fromCurrency`; `0` returns the rate and limits only.
+   */
+  quote(fromCurrency: string, toCurrency: string, fromAmount: number): Promise<ExchangeQuote>;
+  /**
+   * Moves real money and is never retried. After a failure, check balances before trying again.
+   *
+   * @param request - The exchange, in the shape the API takes it.
+   */
+  createExchange(request: ExchangeRequest): Promise<Exchange>;
+  /** Non-zero spot balances against the API total, which also counts staked funds. */
+  portfolio(): Promise<Portfolio>;
+}

package/build/client.js

@@ -0,0 +1,294 @@
+import { Transport, WaltAuthError } from "./transport.js";
+// source/client.ts
+const BASE_URL = "https://walletbot.me";
+const calendarDate = (date) => [
+	date.getUTCFullYear(),
+	date.getUTCMonth() + 1,
+	date.getUTCDate()
+].map((part) => String(part).padStart(2, "0")).join("-");
+const decimal = (value) => {
+	if (typeof value !== "string" || value.trim() === "") return null;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+};
+var WaltClient = class {
+	transport;
+	maxConcurrent;
+	constructor(options) {
+		if (!options.tokenProvider) throw new WaltAuthError("tokenProvider is required");
+		const retries = options.retries ?? 3;
+		this.maxConcurrent = options.maxConcurrent ?? 4;
+		if (!(this.maxConcurrent >= 1)) throw new RangeError(`maxConcurrent must be at least 1, got ${this.maxConcurrent}`);
+		if (!Number.isInteger(retries) || retries < 0) throw new RangeError(`retries must be a whole number of at least 0, got ${retries}`);
+		this.transport = new Transport({
+			tokenProvider: options.tokenProvider,
+			baseUrl: options.baseUrl ?? BASE_URL,
+			fetch: options.fetch ?? fetch,
+			retries,
+			retryDelayMs: options.retryDelayMs ?? 500,
+			maxConcurrent: this.maxConcurrent
+		});
+	}
+	accounts() {
+		return this.transport.get("/api/v1/accounts/");
+	}
+	async coins(fiatCurrency) {
+		const { coins } = await this.transport.get(`/api/v1/coins/list/${fiatCurrency}/`);
+		return coins;
+	}
+	async localCurrency() {
+		const { local_currency } = await this.transport.get("/api/v1/currencies/local_currency/");
+		return local_currency;
+	}
+	transactions(limit, cursor) {
+		const query = new URLSearchParams();
+		if (limit !== void 0) query.set("limit", String(limit));
+		if (cursor !== void 0) query.set("cursor", cursor);
+		const search = query.size === 0 ? "" : `?${query.toString()}`;
+		return this.transport.get(`/api/v1/transactions/${search}`);
+	}
+	accountTransactions(currency, limit, cursor) {
+		const query = new URLSearchParams({ crypto_currency: currency });
+		if (limit !== void 0) query.set("limit", String(limit));
+		if (cursor !== void 0) query.set("cursor", cursor);
+		return this.transport.get(`/api/v1/transactions/single-account/?${query.toString()}`);
+	}
+	async *walk(page) {
+		let cursor;
+		const seen = /* @__PURE__ */ new Set();
+		for (;;) {
+			const current = await page(cursor);
+			if (current.transactions.length === 0) return;
+			yield* current.transactions;
+			if (current.next_cursor === null) return;
+			if (seen.has(current.next_cursor)) throw new Error("transactions pagination returned a cursor twice");
+			seen.add(current.next_cursor);
+			cursor = current.next_cursor;
+		}
+	}
+	allTransactions(limit) {
+		return this.walk((cursor) => this.transactions(limit, cursor));
+	}
+	allAccountTransactions(currency, limit) {
+		return this.walk((cursor) => this.accountTransactions(currency, limit, cursor));
+	}
+	/**
+	* `transactionDetails()` for each listing row, several in flight, yielded in input order.
+	* A lookup that still fails after its retries ends the iteration.
+	*
+	* @param transactions - Listing rows, typically `allTransactions()`.
+	* @yields One detail record per row.
+	*/
+	async *detailsFor(transactions) {
+		const width = Math.max(1, Math.min(this.maxConcurrent, 32));
+		const inFlight = [];
+		try {
+			for await (const transaction of transactions) {
+				const lookup = this.transactionDetails(transaction.id, transaction.gateway);
+				Promise.allSettled([lookup]);
+				inFlight.push(lookup);
+				while (inFlight.length >= width) {
+					const next = inFlight.shift();
+					if (next) yield await next;
+				}
+			}
+			while (inFlight.length > 0) {
+				const next = inFlight.shift();
+				if (next) yield await next;
+			}
+		} finally {
+			await Promise.allSettled(inFlight);
+		}
+	}
+	/**
+	* @param id - Transaction id from a listing row.
+	* @param gateway - The row's `gateway`. Some records, such as `xstocks_dividends`, 404 without it.
+	*/
+	transactionDetails(id, gateway) {
+		const query = gateway ? `?${new URLSearchParams({ transaction_gateway: gateway }).toString()}` : "";
+		return this.transport.get(`/api/v1/transactions/details/${encodeURIComponent(String(id))}/${query}`);
+	}
+	unconfirmedTransactions(limit) {
+		const query = limit === void 0 ? "" : `?${new URLSearchParams({ limit: String(limit) }).toString()}`;
+		return this.transport.get(`/api/v1/transactions/unconfirmed/${query}`);
+	}
+	frozenBalances() {
+		return this.transport.get("/api/v1/accounts/frozen");
+	}
+	/** Every earn campaign. Staked balances are here, not in `accounts()`. */
+	earnCampaigns() {
+		return this.transport.get("/earn/public-api/v1/campaigns/");
+	}
+	/**
+	* Deposits, withdrawals and payouts within one campaign, newest first.
+	*
+	* @param campaignId - `campaign_id` from `earnCampaigns()`.
+	* @param limit - Rows per page. The API defaults to 10.
+	* @param after - The previous page, to fetch the one that follows it.
+	*/
+	earnCampaignTransactions(campaignId, limit, after) {
+		const query = new URLSearchParams();
+		if (limit !== void 0) query.set("limit", String(limit));
+		query.set("merge_with_transfer_requests", "true");
+		if (after?.deposit_acc_next_from != null) query.set("deposit_acc_offset_id", String(after.deposit_acc_next_from));
+		if (after?.payout_acc_next_from != null) query.set("payout_acc_offset_id", String(after.payout_acc_next_from));
+		if (after?.transfer_request_next_before_datetime != null) query.set("transfer_request_before_datetime", after.transfer_request_next_before_datetime);
+		return this.transport.get(`/earn/public-api/v1/campaigns/${encodeURIComponent(String(campaignId))}/transactions?${query.toString()}`);
+	}
+	/**
+	* Every row of `earnCampaignTransactions()`, page by page. The cursors stay set past the last row,
+	* so a page shorter than `limit` ends the walk.
+	*
+	* @param campaignId - `campaign_id` from `earnCampaigns()`.
+	* @param limit - Rows per page.
+	* @yields One row per deposit, withdrawal or payout.
+	*/
+	async *allEarnCampaignTransactions(campaignId, limit = 100) {
+		const seen = /* @__PURE__ */ new Set();
+		let page;
+		for (;;) {
+			page = await this.earnCampaignTransactions(campaignId, limit, page);
+			yield* page.transactions;
+			if (page.transactions.length < limit) return;
+			const cursor = [
+				page.deposit_acc_next_from,
+				page.payout_acc_next_from,
+				page.transfer_request_next_before_datetime
+			].join("|");
+			if (seen.has(cursor)) throw new Error("earn transactions pagination returned a cursor twice");
+			seen.add(cursor);
+		}
+	}
+	earnRate(from, to) {
+		return this.transport.get(`/earn/public-api/v1/rate/${encodeURIComponent(from)}/${encodeURIComponent(to)}`);
+	}
+	pnl() {
+		return this.transport.get("/customer-analytics/public-api/v1/pnl/assets/");
+	}
+	/**
+	* Balance, P/L, deposits and withdrawals per day or per calendar month, plus totals for the whole range.
+	*
+	* @param dateFrom - Start of the first period, as a `Date` or `YYYY-MM-DD`. A `Date` counts by its UTC day.
+	* @param resolution - `1d` for days, `1m` for months.
+	*/
+	portfolioHistory(dateFrom, resolution) {
+		const query = new URLSearchParams({
+			date_from: dateFrom instanceof Date ? calendarDate(dateFrom) : dateFrom,
+			resolution
+		});
+		return this.transport.get(`/customer-analytics/public-api/v1/portfolio/private/?${query.toString()}`);
+	}
+	/**
+	* @param options - Filters, all optional.
+	* @param options.status - Only orders in these states, such as `OPEN`.
+	* @param options.limit - Most orders to return.
+	*/
+	async limitOrders(options = {}) {
+		const query = new URLSearchParams();
+		for (const status of options.status ?? []) query.append("status", status);
+		if (options.limit !== void 0) query.set("limit", String(options.limit));
+		const search = query.size === 0 ? "" : `?${query.toString()}`;
+		const { items } = await this.transport.get(`/emporos/public-api/orders/limit${search}`);
+		return items;
+	}
+	limitOrder(id) {
+		const query = new URLSearchParams({ id });
+		return this.transport.get(`/emporos/public-api/orders/limit/by-id?${query.toString()}`);
+	}
+	/**
+	* Fee and fill for a limit order, without placing it. Only `BUY` is accepted.
+	*
+	* @param baseCurrency - What is bought, from `limitOrderTokens()`.
+	* @param side - `SELL` is a valid value that the API currently rejects.
+	* @param priceLimit - Highest price to pay per unit.
+	* @param size - `amount` to spend, or `quantity` of `baseCurrency` to receive.
+	*/
+	limitOrderQuote(baseCurrency, side, priceLimit, size) {
+		const query = new URLSearchParams({
+			base_currency: baseCurrency,
+			side,
+			price_limit: String(priceLimit)
+		});
+		if ("amount" in size) query.set("amount", String(size.amount));
+		else query.set("quantity", String(size.quantity));
+		return this.transport.get(`/emporos/public-api/orders/limit/quote?${query.toString()}`);
+	}
+	limitOrderBounds(baseCurrency) {
+		const query = new URLSearchParams({ base_currency: baseCurrency });
+		return this.transport.get(`/emporos/public-api/orders/limit/bounds?${query.toString()}`);
+	}
+	/** Every currency a limit order can buy. */
+	async limitOrderTokens() {
+		const { tokens } = await this.transport.get("/emporos/public-api/orders/limit/tokens");
+		return tokens;
+	}
+	coinDetails(currency, fiatCurrency) {
+		return this.transport.get(`/api/v1/coins/details/${encodeURIComponent(currency)}/${encodeURIComponent(fiatCurrency)}/`);
+	}
+	charts(currency, fiatCurrency) {
+		return this.transport.get(`/api/v1/charts/${encodeURIComponent(currency)}/${encodeURIComponent(fiatCurrency)}/`);
+	}
+	priceForFiatAtTime(cryptoCurrency, localCurrency, amount, time) {
+		const query = new URLSearchParams({
+			crypto_currency: cryptoCurrency,
+			local_currency: localCurrency,
+			amount: String(amount),
+			time: time instanceof Date ? time.toISOString() : String(time)
+		});
+		return this.transport.get(`/api/v1/exchange_rates/price_for_fiat_at_time/?${query.toString()}`);
+	}
+	availableExchanges() {
+		return this.transport.get("/api/v1/exchange/get-available-exchanges/");
+	}
+	/**
+	* Executable rate, spread included, unlike the display rates.
+	*
+	* @param fromCurrency - What is paid.
+	* @param toCurrency - What is received.
+	* @param fromAmount - Amount of `fromCurrency`; `0` returns the rate and limits only.
+	*/
+	quote(fromCurrency, toCurrency, fromAmount) {
+		return this.transport.post("/api/v1/exchange/convert/", {
+			from_amount: fromAmount,
+			from_currency: fromCurrency,
+			to_currency: toCurrency
+		});
+	}
+	/**
+	* Moves real money and is never retried. After a failure, check balances before trying again.
+	*
+	* @param request - The exchange, in the shape the API takes it.
+	*/
+	createExchange(request) {
+		return this.transport.post("/api/v1/exchange/create_exchange/", request, 0);
+	}
+	/** Non-zero spot balances against the API total, which also counts staked funds. */
+	async portfolio() {
+		const data = await this.accounts();
+		if (!Array.isArray(data.accounts)) throw new Error("accounts response carries no accounts array");
+		const total = decimal(data.available_balance_total_fiat_amount);
+		if (total === null) throw new Error(`accounts total is not a number: ${String(data.available_balance_total_fiat_amount)}`);
+		const entries = [];
+		for (const account of data.accounts) {
+			const balance = decimal(account.available_balance);
+			if (balance === null) throw new Error(`${account.currency} balance is not a number: ${String(account.available_balance)}`);
+			if (balance <= 0) continue;
+			const fiatValue = decimal(account.available_balance_fiat_amount);
+			if (fiatValue === null) throw new Error(`${account.currency} fiat value is not a number: ${String(account.available_balance_fiat_amount)}`);
+			entries.push({
+				currency: account.currency,
+				amount: account.available_balance,
+				fiatValue
+			});
+		}
+		const entriesTotal = entries.reduce((sum, entry) => sum + entry.fiatValue, 0);
+		return {
+			entries: entries.sort((a, b) => b.fiatValue - a.fiatValue),
+			entriesTotal,
+			total,
+			staked: total - entriesTotal,
+			fiatCurrency: data.available_balance_total_fiat_currency
+		};
+	}
+};
+export { WaltClient };

package/build/index.d.ts

@@ -0,0 +1,10 @@
+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 { 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 { 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 };

package/build/index.js

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

package/build/telegram/auth.d.ts

@@ -0,0 +1,57 @@
+export type TokenState = {
+  jwt: string;
+  refreshToken: string;
+  sessionId: string;
+  expiresAt: number;
+  deviceSerial: string;
+};
+export type TokenStorage = {
+  load: () => Promise<TokenState | null>;
+  save: (state: TokenState) => Promise<void>;
+};
+export type TelegramTokenSourceOptions = {
+  session: string;
+  apiId: number;
+  apiHash: string;
+  bot?: string;
+  deviceSerial?: string;
+  /** Origin of the web app, sent as `origin` and `referer`. */
+  baseUrl?: string;
+  /** Where the auth and refresh requests go. */
+  authUrl?: string;
+  fetch?: typeof fetch;
+  /** Defaults to a file in the user cache directory; `false` keeps the token in memory. */
+  storage?: TokenStorage | false;
+  maxFloodWaitMs?: number;
+};
+export declare class TelegramTokenSource {
+  private readonly client;
+  private readonly bot;
+  private readonly baseUrl;
+  private readonly authUrl;
+  private readonly fetchImpl;
+  private readonly storage;
+  private readonly maxFloodWaitMs;
+  private deviceSerial;
+  private deviceSerialKnown;
+  private jwt;
+  private refreshToken;
+  private sessionId;
+  private expiresAt;
+  private restored;
+  private pending;
+  constructor(options: TelegramTokenSourceOptions);
+  /**
+   * @param rejected - A token the API answered with 401. If it is the cached one, it is renewed even before expiry.
+   */
+  token(rejected?: string): Promise<string>;
+  private fresh;
+  private resolve;
+  private restore;
+  private authenticate;
+  private requestInitData;
+  private refresh;
+  private post;
+  private store;
+  disconnect(): Promise<void>;
+}