@agentgrant.cash/cli 1.4.2 → 1.4.4

package/dist/lib/client.d.ts

@@ -0,0 +1,295 @@
+import type { AssetDto, MarketDto, TxResult, TxStatusResult, PrepareResult, SignStart, SignTaskInput, HlSetup, FiatAccount, PortfolioSummary, PolymarketMarketsResult, PolymarketMarketDetail, PolymarketPositionsResult, PolymarketActivityResult, PolymarketTradingStatus, PolymarketBetResult, VaultDto, EarnPositionDto } from './types.js';
+import type { TokenHolder } from './auth-session.js';
+interface ClientOpts {
+    urls: {
+        api: string;
+        fiat: string;
+        widget: string;
+        app: string;
+    };
+    fetchImpl?: typeof fetch;
+    /** Shared holder of the perfolio access JWT + refresh (drives refresh-on-401). */
+    auth?: TokenHolder;
+}
+export declare class PerfolioClient {
+    private urls;
+    private auth?;
+    private f;
+    constructor(opts: ClientOpts);
+    private headers;
+    /** fetch with an abort-based timeout + one retry on a transient network failure. */
+    private fetchWithTimeout;
+    private request;
+    private get;
+    private post;
+    getUser(): Promise<Record<string, unknown>>;
+    getModuleStatus(): Promise<Record<string, unknown>>;
+    getAssets(): Promise<AssetDto[]>;
+    getMarkets(): Promise<MarketDto[]>;
+    /** Balances for the authenticated user's own wallet (no wallet-id needed). */
+    getBalance(): Promise<unknown>;
+    /**
+     * Portfolio summary. Pass `'full'` to additionally fetch the multi-asset +
+     * perps breakdown (`multiAsset` block) used by the CLI/MCP; the default
+     * (gold + cash) matches what the web app reads.
+     */
+    getPortfolio(view?: 'full'): Promise<PortfolioSummary>;
+    getPosition(collateral: string, loan: string): Promise<unknown>;
+    getGoldPrice(): Promise<unknown>;
+    /**
+     * FX rate for a fiat currency: local units per 1 USD (public endpoint).
+     * Used to convert USD-denominated amounts into the user's display currency.
+     */
+    getFiatRate(currency: string): Promise<{
+        price: number;
+        currency: string;
+        baseCurrency: string;
+    }>;
+    getCryptoPrices(): Promise<unknown>;
+    getBorrowRate(): Promise<unknown>;
+    getMarketStats(): Promise<unknown>;
+    getTxHistory(limit?: number): Promise<unknown>;
+    /** Authoritative per-tx status — backend re-checks the MEE explorer for non-terminal states. */
+    getTxStatus(txHash: string): Promise<TxStatusResult>;
+    /** Discover/search active prediction markets (public). */
+    polymarketMarkets(query?: string, limit?: number): Promise<PolymarketMarketsResult>;
+    /** One market's detail + live prices (public). */
+    polymarketMarket(id: string): Promise<PolymarketMarketDetail>;
+    /** The authenticated user's open prediction positions + portfolio totals. */
+    polymarketPositions(): Promise<PolymarketPositionsResult>;
+    /** The authenticated user's prediction trade history (most recent first). */
+    polymarketActivity(limit?: number): Promise<PolymarketActivityResult>;
+    /** Whether the betting (write) path is provisioned + enabled. */
+    polymarketTradingStatus(): Promise<PolymarketTradingStatus>;
+    /** Place a bet (buy outcome shares). Returns 503 until trading is enabled. */
+    polymarketBet(b: {
+        marketId: string;
+        side: 'yes' | 'no';
+        amount: string;
+        limitPrice?: number;
+        maxSlippageBps?: number;
+    }): Promise<PolymarketBetResult>;
+    /** Sell shares (cash out). `shares` omitted = sell all. */
+    polymarketSell(b: {
+        marketId: string;
+        shares?: number;
+    }): Promise<PolymarketBetResult>;
+    /** Redeem winnings on a resolved market. */
+    polymarketRedeem(b: {
+        marketId: string;
+    }): Promise<{
+        status: string;
+        marketId: string;
+    }>;
+    /** Deposit-wallet address + deployed status (read-only). */
+    polymarketDepositWallet(): Promise<{
+        address: string;
+        deployed: boolean;
+    }>;
+    /** Deploy + approve the deposit wallet (gasless, autonomous via the signer). */
+    polymarketProvision(): Promise<{
+        address: string;
+        deployed: boolean;
+        provisioned: boolean;
+    }>;
+    /** Build a Relay USDT→pUSD funding quote to the deposit wallet (execution is separate). */
+    polymarketFundQuote(amount: string): Promise<{
+        depositWallet: string;
+        amountUsdt: string;
+        requestId?: string;
+        steps: unknown[];
+    }>;
+    /** Execute USDT→pUSD funding to the deposit wallet autonomously via the DeFi session. */
+    polymarketDeposit(amount: string): Promise<{
+        requestId?: string;
+        depositWallet: string;
+    }>;
+    /** Withdraw pUSD from the deposit wallet back to your wallet (USDT on Ethereum). */
+    polymarketWithdraw(amount: string): Promise<{
+        bridgeAddress: string;
+        recipient: string;
+        depositWallet: string;
+        txHash?: string;
+    }>;
+    /** Poll a Relay funding intent (pUSD delivery on Polygon). */
+    polymarketFundStatus(requestId: string): Promise<unknown>;
+    swapQuote(b: {
+        sellToken: string;
+        buyToken: string;
+        sellAmount: string;
+    }): Promise<unknown>;
+    swap(b: {
+        sellToken: string;
+        buyToken: string;
+        sellAmount: string;
+    }): Promise<TxResult>;
+    supply(b: {
+        collateral: string;
+        amount: string;
+    }): Promise<TxResult>;
+    borrow(b: {
+        collateral: string;
+        loan: string;
+        amount: string;
+    }): Promise<TxResult>;
+    repay(b: {
+        collateral: string;
+        loan: string;
+        amount: string;
+    }): Promise<TxResult>;
+    withdrawCollateral(b: {
+        collateral: string;
+        amount: string;
+    }): Promise<TxResult>;
+    supplyAndBorrow(b: {
+        collateral: string;
+        loan: string;
+        collateralAmount: string;
+        borrowAmount: string;
+    }): Promise<TxResult>;
+    closePosition(b: {
+        collateral: string;
+        loan: string;
+    }): Promise<TxResult>;
+    /** List earn vaults (public read). Pass an asset symbol to filter. */
+    getVaults(asset?: string): Promise<{
+        vaults: VaultDto[];
+    }>;
+    /** The authenticated user's earn position for an asset (on-chain shares + value). */
+    getEarnPosition(asset: string): Promise<EarnPositionDto>;
+    /** Deposit an asset into its canonical earn vault (agent-signed via the DeFi session). */
+    earnDeposit(b: {
+        asset: string;
+        amount: string;
+    }): Promise<TxResult>;
+    /** Withdraw from an earn vault — exact `amount`, or the whole position with `all: true`. */
+    earnWithdraw(b: {
+        asset: string;
+        amount?: string;
+        all?: boolean;
+    }): Promise<TxResult>;
+    prepareWithdrawal(b: {
+        token: string;
+        recipient: string;
+        amount: string;
+    }): Promise<PrepareResult>;
+    prepareGiftSend(b: {
+        recipientEmail?: string;
+        recipientPhone?: string;
+        amountXaut: string;
+        message?: string;
+    }): Promise<PrepareResult>;
+    /** Hand a self-describing sign task to the browser-sign relay. Returns the approve URL + sid. */
+    signStart(b: SignTaskInput): Promise<SignStart>;
+    hlStatus(): Promise<Record<string, unknown>>;
+    /** Discover tradeable HL markets (crypto + equities/commodities/fx/indices). */
+    hlMarkets(search?: string): Promise<{
+        markets: Array<{
+            symbol: string;
+            fullName: string;
+            dex: string;
+            category: string;
+            maxLeverage: number;
+        }>;
+        count: number;
+    }>;
+    hlPositions(): Promise<{
+        positions: unknown[];
+    }>;
+    hlOrders(): Promise<{
+        orders: unknown[];
+    }>;
+    hlOrderHistory(): Promise<{
+        orders: unknown[];
+    }>;
+    hlTradeHistory(limit?: number): Promise<unknown>;
+    hlPrice(asset?: string): Promise<unknown>;
+    hlSetup(): Promise<HlSetup>;
+    hlOpen(b: {
+        side: 'long' | 'short';
+        sizeUsd: number;
+        leverage: number;
+        asset?: string;
+    }): Promise<unknown>;
+    hlClose(b: {
+        asset: string;
+        sizePct?: number;
+    }): Promise<unknown>;
+    hlSetLeverage(b: {
+        leverage: number;
+        isCross: boolean;
+    }): Promise<unknown>;
+    hlTpsl(b: {
+        asset: string;
+        side: 'long' | 'short';
+        size: string;
+        takeProfit?: number;
+        stopLoss?: number;
+    }): Promise<unknown>;
+    hlCancelOrder(b: {
+        oid: number;
+        asset?: string;
+    }): Promise<unknown>;
+    /**
+     * Autonomous USDT → Hyperliquid deposit. Hits POST /tx/bridge-deposit, which
+     * builds the USDT-approve + Across bridge calls and executes them via the
+     * Biconomy session grant (agent-signed) — no user signature, no browser.
+     * (The old /hl/deposit/one-click only PREPARED calldata and executed nothing,
+     * so its "submitted" was a false positive that moved no funds.)
+     */
+    hlDeposit(b: {
+        amountUsdt: string;
+    }): Promise<TxResult>;
+    /**
+     * Autonomous cash → spending bridge. Hits POST /tx/bridge-base, which builds
+     * the USDT-approve + Across bridge (ETH USDT → Base USDC) and executes them via
+     * the Biconomy defi session grant (agent-signed) — no user signature, no
+     * browser. Funds the Grant Cash agent's USDC spending balance on Base. A
+     * returned txHash means the Ethereum leg was SUBMITTED; the spending balance
+     * updates on Base a few minutes later once Across fills. Mirrors hlDeposit
+     * (/tx/bridge-deposit) — same Across Swap API + session execution; only the
+     * destination (Base 8453) and output token (USDC) differ.
+     */
+    bridgeToBase(b: {
+        amountUsdt: string;
+    }): Promise<{
+        txHash?: string;
+        status?: string;
+        quote?: {
+            inputAmount?: string;
+            outputAmount?: string;
+            estimatedTimeSec?: number;
+        };
+    }>;
+    /** Autonomous HL → Ethereum withdrawal (server-signs via Privy; no browser). */
+    hlWithdraw(b: {
+        amountUsdc: string;
+    }): Promise<{
+        amount?: string;
+        status?: string;
+        relayRequestId?: string;
+        expectedOutputUsdt?: string;
+        estimatedTimeSec?: number;
+        recipient?: string;
+    }>;
+    /** Poll a HL→Ethereum withdrawal to completion (Relay canonical status + delivery tx hashes). */
+    hlWithdrawStatus(requestId: string): Promise<{
+        status: string;
+        requestId: string;
+        inTxHashes?: string[];
+        outTxHashes?: string[];
+    }>;
+    kycStatus(): Promise<unknown>;
+    /** Provider (Roma) accounts — fiat accounts carry bankDetails for deposits. Auto-provisioned after KYC. */
+    getAccounts(): Promise<FiatAccount[]>;
+    beneficiaries(): Promise<unknown>;
+    fiatQuote(b: {
+        sourceAmount: string;
+        sourceCurrencyCode: string;
+        destinationCurrencyCode: string;
+    }): Promise<unknown>;
+    giftsSent(): Promise<unknown>;
+    giftsReceived(): Promise<unknown>;
+    updateSettings(b: Record<string, unknown>): Promise<unknown>;
+}
+export {};

package/dist/lib/config.d.ts

@@ -0,0 +1,13 @@
+import type { BaseUrls, Credentials } from "./types.js";
+/**
+ * Backend base URLs — env-overridable. Defaults point at the DEVELOP environment
+ * (this is an internal/testing CLI for now). Set the env vars (in a `.env` in the
+ * directory you run the CLI from, or as exported shell vars) to repoint at
+ * localhost/staging/production without touching code. The active backend is shown
+ * by `grant config show` / `grant status`.
+ */
+export declare function baseUrls(env?: NodeJS.ProcessEnv): BaseUrls;
+export declare function resolveCredsPath(flag?: string, env?: NodeJS.ProcessEnv): string;
+export declare function loadCredentials(path: string): Credentials;
+export declare function saveCredentials(creds: Credentials, path: string): void;
+export declare function clearCredentials(path: string): void;

package/dist/lib/context.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { BaseUrls, Credentials } from "./types.js";
+import { MoneyClient } from "./money-client.js";
+import { AgentClient } from "./agent-client.js";
+/**
+ * Per-invocation runtime: resolved URLs, the credential, both backend clients, and
+ * the output mode. Built once per command from the global flags. Both clients share
+ * ONE {@link TokenHolder} (unified auth) so a 401 from either refreshes the single
+ * perfolio access JWT once and persists it back to the credentials file.
+ */
+export interface Ctx {
+    urls: BaseUrls;
+    creds: Credentials;
+    credsPath: string;
+    json: boolean;
+    money: MoneyClient;
+    agent: AgentClient;
+    /** Persist a credentials mutation back to disk. */
+    save: (next: Credentials) => void;
+}
+export declare function buildContext(cmd: Command): Ctx;

package/dist/lib/currency.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Display-currency + experience-mode formatting — the single source of truth
+ * shared by the CLI and the MCP server.
+ *
+ * The platform stores all monetary values internally in USD. The user's profile
+ * (GET /api/user) carries their display preferences:
+ *   - currency        ISO code of their local currency (e.g. INR, AED, EUR)
+ *   - displayCurrency  'USD' (show USD) | 'local' (convert to `currency`)
+ *   - goldDisplayUnit  'oz' | 'g'
+ *   - experienceMode   'simple' (plain language, local currency) | 'advanced'
+ *
+ * The FX rate (local units per 1 USD) comes from GET /api/prices/fiat/{currency}.
+ * Conversion is a single multiply; presentation is delegated to Intl so symbols
+ * and per-currency decimal conventions (e.g. JPY has 0) are correct and we don't
+ * hand-maintain a symbol table.
+ */
+export type ExperienceMode = 'simple' | 'advanced';
+export type DisplayCurrencyMode = 'USD' | 'local';
+export type GoldUnit = 'oz' | 'g';
+/** 1 troy ounce = 31.1034768 grams (matches the web app's GRAMS_PER_TROY_OUNCE). */
+export declare const GRAMS_PER_TROY_OUNCE = 31.1034768;
+export interface DisplayPrefs {
+    /** ISO currency code of the user's local currency. */
+    currency: string;
+    /** Whether to render money in USD or the local `currency`. */
+    displayCurrency: DisplayCurrencyMode;
+    /** Whether to render gold weight in ounces or grams. */
+    goldUnit: GoldUnit;
+    /** Experience mode — drives jargon level and the USD-vs-local default. */
+    mode: ExperienceMode;
+    /** Local currency units per 1 USD. 1 means "no conversion / USD". */
+    rate: number;
+}
+/** Safe USD-only defaults — what every caller falls back to with no profile. */
+export declare const DEFAULT_PREFS: DisplayPrefs;
+/**
+ * Build DisplayPrefs from a raw GET /api/user payload (defensively — the field
+ * may be absent on legacy rows) plus a fetched FX rate. Unknown / malformed
+ * values fall back to the safe USD defaults rather than throwing.
+ */
+export declare function resolveDisplayPrefs(user: unknown, rate?: number): DisplayPrefs;
+/** True when money should be shown in the user's local currency (not USD). */
+export declare function usesLocalCurrency(prefs: DisplayPrefs): boolean;
+/**
+ * Format a USD amount for display per the user's preferences. Converts to the
+ * local currency when configured; otherwise renders USD. Always falls back to a
+ * valid USD string if the target currency code is not recognized by Intl.
+ */
+export declare function formatMoney(amountUsd: number, prefs?: DisplayPrefs): string;
+/**
+ * A compact, machine-readable descriptor of the user's money-display settings.
+ * Attach this to `--json` output so a consumer (e.g. an agent) knows the currency
+ * the user expects amounts in, and the FX rate (local units per 1 USD) needed to
+ * convert the USD figures the backend returns. Mirrors the MCP's display descriptor.
+ */
+export interface DisplayDescriptor {
+    currency: string;
+    displayCurrency: DisplayCurrencyMode;
+    goldUnit: GoldUnit;
+    /** Local units per 1 USD (1 when showing USD). */
+    rate: number;
+    /** True when amounts should be presented in `currency`, not USD. */
+    usesLocal: boolean;
+}
+export declare function displayDescriptor(prefs?: DisplayPrefs): DisplayDescriptor;
+/**
+ * Format a gold amount (given in troy ounces) per the user's unit preference.
+ * Grams are shown with more precision than ounces since 1 oz ≈ 31 g.
+ */
+export declare function formatGold(ounces: number, prefs?: DisplayPrefs): string;

package/dist/lib/device.d.ts

@@ -0,0 +1,78 @@
+export interface DeviceStart {
+    sid: string;
+    connectUrl: string;
+    pollInterval: number;
+    expiresIn: number;
+}
+export interface DeviceCredentials {
+    /** perfolio-signed access JWT — the Bearer for BOTH backends (unified auth). */
+    accessJwt?: string;
+    refreshToken: string;
+    email: string;
+    walletAddress: string;
+    expiresAt: number;
+    deviceId: string;
+    /** @deprecated legacy `pfk_` token — still on the wire during migration; unused. */
+    token?: string;
+}
+export type DevicePoll = {
+    status: "pending" | "denied" | "expired";
+} | {
+    status: "complete";
+    result: DeviceCredentials;
+};
+export interface CliDevice {
+    deviceId: string;
+    clientName: string;
+    deviceName: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export declare function startDevice(api: string, clientName: string, deviceName: string, f?: typeof fetch): Promise<DeviceStart>;
+/**
+ * One poll tick. Resolves only on a real backend answer (HTTP 200 + success
+ * envelope) — `pending` | `denied` | `expired` | `complete`. Any transient
+ * failure (429 from the shared `/api` limiter, a 5xx, a malformed body, or a
+ * thrown fetch when the dev backend restarts) is raised as an AppError so
+ * {@link waitForDevice} can back off and retry inside the window instead of
+ * mistaking a blip for a terminal "expired" and giving up. A 429 carries
+ * `retryInMs` (from the body or the `Retry-After` header) for the backoff.
+ *
+ * This mirrors the agent side (`pollAgentDevice`/`waitForAgentDevice`); the two
+ * halves of the handshake must be equally fault-tolerant.
+ */
+export declare function pollDevice(api: string, sid: string, f?: typeof fetch): Promise<DevicePoll>;
+/**
+ * Poll until a genuine terminal status or the link expires.
+ *
+ * Never bails on a transient failure: network errors and rate-limits (honoring
+ * `retryInMs`) just back off and retry until the window closes. Only a real
+ * backend answer (`complete` / `denied` / `expired`) ends the loop early. On
+ * window exhaustion returns `{ status: "expired" }`.
+ */
+export declare function waitForDevice(api: string, sid: string, intervalMs: number, timeoutMs: number, f?: typeof fetch): Promise<DevicePoll>;
+/**
+ * Resolve the money-side poll interval in MILLISECONDS.
+ *
+ * The Perfolio money backend (`cli/device/start`) reports `pollInterval` already
+ * in milliseconds (e.g. 3000) — the same contract the published @perfolio/cli
+ * consumes as-is — so it is used verbatim. This deliberately differs from the
+ * agent backend, which reports SECONDS (see {@link agentPollIntervalMs}).
+ *
+ * Multiplying this value by 1000 was the cause of the "browser connected but CLI
+ * polls forever" bug: 3000 became 3,000,000ms (~50 min), so the CLI polled once
+ * and then slept past the whole login window. Falls back to 3s.
+ */
+export declare function moneyPollIntervalMs(pollInterval: number | undefined): number;
+export declare function refreshCliToken(api: string, refreshToken: string, f?: typeof fetch): Promise<{
+    token: string;
+    refreshToken: string;
+    expiresAt: number;
+}>;
+/** List the devices/agents connected to this account (Bearer auth). */
+export declare function listDevices(api: string, token: string, f?: typeof fetch): Promise<CliDevice[]>;
+export declare function revokeDevice(api: string, token: string, deviceId: string | undefined, f?: typeof fetch): Promise<void>;
+/** Best-effort label for the agent/client making the connection. */
+export declare function detectClient(env?: NodeJS.ProcessEnv): string;
+/** Open a URL in the user's default browser (best-effort; never throws). */
+export declare function openBrowser(url: string): void;

package/dist/lib/dotenv.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Minimal, dependency-free `.env` loader.
+ *
+ * Reads `path` and applies each `KEY=value` line into `env`, but ONLY for keys
+ * that are still unset — so an already-exported shell var (or an earlier-loaded
+ * file) always wins. Missing/unreadable files are a no-op. Supports quoted values
+ * (verbatim, including `#`) and strips trailing inline comments on unquoted values
+ * (the dotenv convention). Returns the keys it actually set (for logging/tests).
+ */
+export declare function applyDotEnv(raw: string, env?: NodeJS.ProcessEnv): string[];
+/** Load a `.env` file by path into `env` (no-op if the file is missing). */
+export declare function loadDotEnvFile(path: string, env?: NodeJS.ProcessEnv): string[];

package/dist/lib/errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Unified error model across both backends.
+ *
+ * Carries a machine `code` and a `recoverable` flag (from the agent side's LLM
+ * playbook) plus an HTTP `status` (from the money side). `friendlyError` maps the
+ * shared connection/availability states to one plain-language line so the same
+ * 401/403/428/503 reads the same no matter which backend produced it.
+ */
+export declare class AppError extends Error {
+    status?: number;
+    code?: string;
+    recoverable?: boolean;
+    details?: Record<string, unknown>;
+    constructor(message: string, opts?: {
+        status?: number;
+        code?: string;
+        recoverable?: boolean;
+        details?: Record<string, unknown>;
+    });
+}
+/** Money side returns 428 when no spending session is installed. */
+export declare class NoSessionError extends AppError {
+    constructor();
+}
+/** No credential of the kind a command needs. */
+export declare class NotConnectedError extends AppError {
+    constructor(which: "money" | "agent" | "any");
+}
+/**
+ * Plain-language override for shared connection states. Returns null when there
+ * is no special-cased message (the caller then uses the backend's own message).
+ */
+export declare function friendlyError(status?: number, code?: string): string | null;

package/dist/lib/format.d.ts

@@ -0,0 +1,5 @@
+/** Display formatting. Plain money, no tickers/chains (Grant Cash house style). */
+export declare function money(n: number, currency?: string): string;
+/** Agent-side amounts arrive as USDC minor units (1e6). */
+export declare function usdcMinor(minor: string | number | undefined): string;
+export declare function pct(n: number, digits?: number): string;

package/dist/lib/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./dotenv.js";
+export * from "./errors.js";
+export * from "./output.js";
+export * from "./device.js";
+export * from "./auth-session.js";
+export * from "./money-client.js";
+export * from "./agent-client.js";
+export * from "./tx-wait.js";
+export * from "./format.js";
+export * from "./currency.js";
+export * from "./portfolio-format.js";
+export * from "./context.js";
+export * from "./client.js";
+export * from "./assets.js";
+export * from "./amounts.js";
+export * from "./money-input.js";
+export * from "./kyc-status.js";
+export * from "./polygon-balance.js";
+export * from "./sign.js";
+export * from "./relay.js";

package/dist/lib/kyc-status.d.ts

@@ -0,0 +1,10 @@
+/** Pure KYC status classifiers — mirror the web app's kyc-status semantics. */
+export declare function isKycApproved(status: unknown): boolean;
+export declare function isKycRejected(status: unknown): boolean;
+export declare function isKycSubmitted(status: unknown): boolean;
+export declare function isKycPending(status: unknown): boolean;
+/** Extract a status string from a raw value (string | {status} | {data:{status}}) and classify it. */
+export declare function classifyKyc(raw: unknown): {
+    status: string;
+    approved: boolean;
+};

package/dist/lib/money-client.d.ts

@@ -0,0 +1,66 @@
+import type { TxResult, TxStatusResult } from "./types.js";
+import type { TokenHolder } from "./auth-session.js";
+export interface MoneyClientOpts {
+    api: string;
+    fiat: string;
+    /** Shared holder of the perfolio access JWT + refresh (drives refresh-on-401). */
+    auth?: TokenHolder;
+    fetchImpl?: typeof fetch;
+}
+export declare class MoneyClient {
+    private api;
+    private fiat;
+    private auth?;
+    private f;
+    constructor(opts: MoneyClientOpts);
+    get connected(): boolean;
+    private headers;
+    private fetchWithTimeout;
+    private request;
+    private get;
+    private post;
+    getUser(): Promise<Record<string, unknown>>;
+    /** Portfolio summary; 'full' adds the multi-asset + perps breakdown. */
+    getPortfolio(view?: "full"): Promise<Record<string, unknown>>;
+    getBalance(): Promise<Record<string, unknown>>;
+    getGoldPrice(): Promise<Record<string, unknown>>;
+    getCryptoPrices(): Promise<Record<string, unknown>>;
+    /** Local units per 1 USD, for display-currency conversion. */
+    getFiatRate(currency: string): Promise<{
+        price: number;
+        currency: string;
+        baseCurrency: string;
+    }>;
+    getTxHistory(limit?: number): Promise<unknown>;
+    getTxStatus(txHash: string): Promise<TxStatusResult>;
+    /** Swap cash → gold (buy) or gold → cash (sell), via the DeFi session. */
+    swap(b: {
+        sellToken: string;
+        buyToken: string;
+        sellAmount: string;
+    }): Promise<TxResult>;
+    /** Prediction deposit-wallet address + deployed status. */
+    polymarketDepositWallet(): Promise<{
+        address: string;
+        deployed: boolean;
+    }>;
+    /** Open prediction positions + portfolio totals (incl. spendable cashUsd). */
+    polymarketPositions(): Promise<{
+        positions: unknown[];
+        count: number;
+        investedUsd: number;
+        valueUsd: number;
+        pnlUsd: number;
+        pnlPercent: number;
+        /**
+         * Spendable pUSD cash in the deposit wallet (deposited-but-unbet funds),
+         * read on-chain server-side — the value the predictions screen shows.
+         * Optional: older backends omit it (callers fall back to a direct read).
+         */
+        cashUsd?: number;
+    }>;
+    /** The user's earn (vault) position for an asset symbol. */
+    getEarnPosition(asset: string): Promise<Record<string, unknown>>;
+    kycStatus(): Promise<Record<string, unknown>>;
+    getAccounts(): Promise<unknown>;
+}