@agentgrant.cash/cli 1.4.2 → 1.4.4

package/dist/cli/commands/agent.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+/**
+ * Agent side — pay-per-use services routed to the Agent-mode backend. Every
+ * spend is owned by the session (delegated, revocable, guardrailed); the CLI
+ * carries only the API key. Verbs mirror the agent CLI so a model that knows it
+ * drives this with no relearning: search → check → fetch.
+ */
+export declare function registerAgent(program: Command): void;

package/dist/cli/commands/auth.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import { type Credentials, type DeviceCredentials } from "../../lib/index.js";
+/**
+ * `grant login` — one connect, one credential (unified auth).
+ *
+ * Runs a SINGLE perfolio device handshake: `cli/device/*`, the one-time `sid`
+ * relayed to the browser via the connect URL. The logged-in browser completes it
+ * server-side; the CLI polls until perfolio returns the credential. The result is
+ * the perfolio-signed access JWT (`accessJwt`) plus the opaque `pfr_` refresh
+ * token — that ONE JWT is sent as `Authorization: Bearer` to BOTH backends
+ * (money + agent). The old agent-side `grant_live_` PKCE leg is retired: there is
+ * no second handshake, no `--agent-key`, no separate spending credential.
+ */
+/**
+ * Map a completed perfolio device flow to the stored credential. A fresh login
+ * REPLACES the whole credentials file — no stale agent key is carried over (the
+ * `grant_live_` leg is gone) — so the file holds exactly one perfolio credential.
+ */
+export declare function loginCredentials(result: DeviceCredentials): Credentials;
+export declare function registerAuth(program: Command): void;

package/dist/cli/commands/meta.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerMeta(program: Command): void;

package/dist/cli/commands/money.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerMoney(program: Command): void;

package/dist/cli/commands/onboard.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerOnboard(program: Command): void;

package/dist/cli/commands/portfolio.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import { type Ctx, type PortfolioExtras } from "../../lib/index.js";
+/**
+ * Prediction available cash + open-bet value. Best-effort; {} on any failure.
+ *
+ * Available cash comes from the SAME source the predictions screen uses: the
+ * backend `/polymarket/positions` `cashUsd` field (an on-chain pUSD read done
+ * server-side via a reliable RPC). For older backends that don't return it we
+ * fall back to reading the deposit wallet's pUSD balance directly from a public
+ * Polygon RPC. Both the positions call and the deposit-wallet lookup run in
+ * parallel so the fallback adds no latency in the common case.
+ */
+export declare function gatherPredictions(ctx: Ctx): Promise<PortfolioExtras>;
+export declare function registerPortfolio(program: Command): void;

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/money-helpers.d.ts

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { PerfolioClient, AssetResolver, type Credentials, type TxResult, type SignTaskInput, type DisplayPrefs, type MoneyResolution, type CashTargetResolution, type ResolvedAsset } from "../lib/index.js";
+/**
+ * Money-side command context — bridges the merged Grant Cash credentials to the
+ * ported Perfolio money engine.
+ *
+ * The standalone Perfolio CLI stored a FLAT credential ({ token, refreshToken,
+ * … }); Grant Cash stores a MERGED file ({ money: {...}, agent: {...} }). Both
+ * mint the same `pfk_` device token against the same Perfolio backend, so the
+ * only adaptation needed is reading/writing the `money` slot. Everything
+ * downstream (PerfolioClient, resolvers, sign flow) is reused verbatim.
+ */
+export interface Ctx {
+    client: PerfolioClient;
+    creds: Credentials;
+    credsPath: string;
+    json: boolean;
+}
+export declare function buildCtx(cmd: Command): Ctx;
+export declare function requireAuth(ctx: Ctx): Credentials;
+/** Load assets once and build a resolver. */
+export declare function resolver(ctx: Ctx): Promise<AssetResolver>;
+/**
+ * Resolve a user-entered CASH amount into a USD decimal string for the backend.
+ * A bare number is interpreted in the user's display currency; an explicit
+ * currency prefix ("$10", "₹50", "100 EUR") always wins. Non-USD amounts are
+ * converted via the live FX rate; refuses (throws) if that rate is unavailable.
+ */
+/**
+ * Force a bare numeric amount to USD by prefixing `$`. An amount the user already
+ * qualified with a currency ($/₹/€/ISO code) is left untouched — an explicit
+ * currency always wins (same rule money-input enforces). So `--usd` + "50" → "$50",
+ * but `--usd` + "₹50" stays ₹50.
+ */
+export declare function forceUsdAmount(raw: string): string;
+export declare function resolveCash(ctx: Ctx, raw: string, decimals: number, opts?: {
+    usd?: boolean;
+}): Promise<MoneyResolution>;
+/**
+ * Live USD unit price for a spot asset, used to size a cash-target sell:
+ * gold → gold spot; btc/eth → /prices/crypto; stable → 1:1. Throws if the
+ * price can't be resolved (caller refuses to guess a quantity).
+ */
+export declare function assetUsdPrice(ctx: Ctx, asset: ResolvedAsset): Promise<number>;
+/**
+ * Resolve a cash-denominated SELL/CONVERT target ("sell ₹100 of gold") into a
+ * quantity of the asset to sell. Refuses (throws) if either the FX rate or the
+ * asset price is unavailable — never guesses a money quantity.
+ */
+export declare function resolveCashTargetQty(ctx: Ctx, asset: ResolvedAsset, cashRaw: string): Promise<CashTargetResolution>;
+/**
+ * Resolve the user's money-display preferences (currency, USD-vs-local, gold
+ * unit, experience mode) plus the live FX rate. Any failure falls back to safe
+ * USD defaults rather than breaking a read command.
+ */
+export declare function loadDisplayPrefs(ctx: Ctx): Promise<DisplayPrefs>;
+/**
+ * Build the money-side SUCCESS envelope. The whole CLI — money and agent sides —
+ * speaks one contract: `{ ok: true, ...data }`. A plain object is spread in; an
+ * array / primitive is nested under `data` (spreading an array would splay its
+ * indices as keys). A redundant top-level `success` marker is dropped so `ok` is
+ * the single source of truth (closes the "trade cmds use {success:true}" gap).
+ * Pure + exported for unit testing.
+ */
+export declare function buildOutPayload(data: unknown): Record<string, unknown>;
+/** Build the money-side FAILURE envelope: `{ ok:false, error:{code,message,recoverable} }`. */
+export declare function buildErrorPayload(msg: string, opts?: {
+    code?: string;
+    recoverable?: boolean;
+}): {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+};
+export declare function out(ctx: Ctx, human: string, data: unknown): void;
+export declare function fail(msg: string, json: boolean, opts?: {
+    code?: string;
+    recoverable?: boolean;
+}): never;
+/**
+ * Report the outcome of a write. With `wait` (the default), poll the tx to a
+ * terminal state and report success/failure honestly — never "submitted". A
+ * failed tx exits non-zero; a timeout is reported as still-pending.
+ */
+export declare function reportTx(ctx: Ctx, res: TxResult, wait: boolean, label: string): Promise<void>;
+/**
+ * Browser-sign hand-off for user-signed operations (withdrawal, gift, HL agent
+ * approval). The CLI prepared a self-describing sign task; here we hand it to
+ * the relay, open the browser for the user to sign + execute, then (for on-chain
+ * ops) confirm the resulting tx. The agent never holds a key — the user's Privy
+ * wallet signs.
+ */
+export declare function runSignFlow(ctx: Ctx, opts: {
+    task: SignTaskInput;
+    label: string;
+    confirmTx?: boolean;
+}): Promise<boolean>;

package/dist/cli/perfolio-commands/account.d.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import { type FiatAccount } from '../../lib/index.js';
+export type DepositGate = {
+    ok: true;
+    status: string;
+} | {
+    ok: false;
+    reason: 'KYC_REQUIRED' | 'PROVISIONING';
+    status: string;
+};
+/** Decide whether deposit details can be shown, or what's blocking. */
+export declare function decideDepositGate(status: unknown, accounts: FiatAccount[]): DepositGate;
+/**
+ * A real fiat deposit target = a non-empty IBAN or account number. Crypto accounts
+ * (USDT_ETH/USDC_ETH) come back with a bankDetails object full of EMPTY strings, so a
+ * mere "object exists / has keys" check is not enough — test the actual wire target.
+ */
+export declare function hasDepositDetails(a: FiatAccount): boolean;
+/** Keep only accounts you can actually wire money to (skips crypto accounts), optionally filtered by currency. */
+export declare function mapDepositAccounts(accounts: FiatAccount[], currency?: string): FiatAccount[];
+/** Render a single account's bank-transfer details, tolerating both field-name variants. */
+export declare function formatBankDetails(a: FiatAccount): string;
+interface GraceOpts {
+    timeoutMs: number;
+    intervalMs: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+/** Poll a KYC status fetcher until approved or a hard timeout. Never blocks past timeoutMs. */
+export declare function gracePollKyc(getStatus: () => Promise<unknown>, opts: GraceOpts): Promise<{
+    approved: boolean;
+    status: string;
+}>;
+export declare function registerAccount(program: Command): void;
+export {};

package/dist/cli/perfolio-commands/borrow.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerBorrow(program: Command): void;

package/dist/cli/perfolio-commands/discover.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerDiscover(program: Command): void;

package/dist/cli/perfolio-commands/earn.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Whether an earn asset is a stablecoin (cash). Stable amounts are MONEY — entered
+ * in the user's currency and FX-resolved to USD (so "100" = ₹100 for an INR user,
+ * consistent with buy/borrow). Non-stable assets (WETH) keep asset-QUANTITY input
+ * (0.5 WETH = 0.5 WETH), like selling an asset by quantity. Exported for testing.
+ */
+export declare function isStableEarnAsset(symbol: string): boolean;
+export declare function registerEarn(program: Command): void;

package/dist/cli/perfolio-commands/hyperliquid.d.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { type DisplayPrefs } from '../../lib/index.js';
+/**
+ * Hyperliquid's minimum order value ($10 notional). Used for a client-side
+ * pre-submit warning; the backend remains authoritative and re-validates.
+ */
+export declare const HL_MIN_ORDER_USD = 10;
+/**
+ * Pre-submit minimum-order check. Returns a currency-aware warning string when
+ * `sizeUsd` is below Hyperliquid's $10 minimum, else null. Exported for testing.
+ *
+ * Renders the minimum in the user's display currency (e.g. ₹800 for an INR user
+ * at rate 80) so CLI traders see an amount in their own terms rather than a bare
+ * "$10" — the gap that left CLI users guessing why orders were rejected.
+ */
+export declare function minOrderHint(sizeUsd: number, prefs: DisplayPrefs, minUsd?: number): string | null;
+/**
+ * Human-readable Hyperliquid account summary. Balance/equity/margin come back as
+ * USD strings; localize them. Exported for testing. Shape (from backend
+ * GET /api/hl/status): { isSetup, isApproved, balance, equity, availableMargin, marginUsed }.
+ */
+export declare function formatHlStatus(data: Record<string, unknown>, prefs: DisplayPrefs): string;
+/**
+ * Hyperliquid perpetual trading.
+ *
+ * Reads + trades are AUTONOMOUS — the backend signs with a server-held,
+ * encrypted per-user agent key (HL's native API-wallet). The only step that
+ * needs the user is the one-time agent approval (`hl setup`), which signs an
+ * EIP-712 ApproveAgent action in the browser via the sign relay. After that,
+ * open/close/leverage/tpsl all run with no further interaction.
+ */
+export declare function registerHyperliquid(program: Command): void;

package/dist/cli/perfolio-commands/loans.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+/**
+ * Loan + funding-address commands ported from the standalone Perfolio CLI. The
+ * combined `grant portfolio` / `grant balance` view (which folds in predictions
+ * + earn) lives separately in commands/portfolio.ts — these are the
+ * loan-detail and deposit-address commands that have no combined-view overlap.
+ */
+export declare function registerLoans(program: Command): void;

package/dist/cli/perfolio-commands/market.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { type DisplayPrefs } from '../../lib/index.js';
+/**
+ * If a price feed is flagged stale, return a loud inline warning (e.g. " ⚠ stale
+ * (16h old)"); '' when fresh/unknown. A quiet `stale:true` boolean was easy to miss
+ * — acting on a 16-hour-old gold mark is a real risk, so it must be visible.
+ */
+export declare function staleNote(src: unknown): string;
+/** Human-readable price board, localized to the user's currency + gold unit. Exported for tests. */
+export declare function formatPrices(gold: unknown, crypto: unknown, prefs: DisplayPrefs): string;
+export declare function registerMarket(program: Command): void;

package/dist/cli/perfolio-commands/polymarket.d.ts

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+import { type DisplayPrefs, type PolymarketMarket, type PolymarketPositionsResult, type PolymarketActivity } from '../../lib/index.js';
+/**
+ * True if an error means the betting path is unavailable, so BOTH `--side yes`
+ * and `--side no` surface the same friendly line. The configured-off state comes
+ * back as 503 / POLYMARKET_TRADING_NOT_CONFIGURED, but the disabled `no` path was
+ * observed returning a bare upstream 502 (and 504 is the same class of gateway
+ * outage) — treat those as unavailable too rather than leaking a raw "HTTP 502".
+ * Exported for unit testing.
+ */
+export declare function isTradingDisabled(err: unknown): boolean;
+/** Render a market list into human-readable lines. Exported for unit testing. */
+export declare function formatMarkets(markets: PolymarketMarket[], count: number): string;
+/**
+ * Render the prediction portfolio: a per-position table showing where each
+ * position has moved (entry → now, %) plus portfolio totals. Money is localized
+ * to the user's currency (defaults to USD for callers without prefs). Exported for tests.
+ */
+export declare function formatPositions(r: PolymarketPositionsResult, prefs?: DisplayPrefs): string;
+/** Render prediction trade history (most recent first). Money localized. Exported for tests. */
+export declare function formatActivity(activity: PolymarketActivity[], prefs?: DisplayPrefs): string;
+/**
+ * Friendly one-liner for a funding-intent status. The backend relays an opaque
+ * tracker payload, so we defensively pull a `status` string (top-level or nested
+ * under `data`) and map the common terminal states to plain language; anything
+ * unrecognized degrades to "still on its way". Exported for tests.
+ */
+export declare function formatFundStatus(raw: unknown): string;
+export declare function registerPolymarket(program: Command): void;

package/dist/cli/perfolio-commands/session.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSession(program: Command): void;

package/dist/cli/perfolio-commands/spending.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+/**
+ * Spending account — the agent's pay-per-use balance (USDC on Base). It is
+ * funded by bridging cash out of the main account, mirroring the other
+ * account-to-account transfers already in the CLI:
+ *   - cash ↔ trading      → `hl deposit` / `hl withdraw`
+ *   - cash ↔ predictions  → `polymarket deposit` / `polymarket withdraw`
+ *   - cash → spending      → `spending deposit`   (this file)
+ *
+ * The reverse (spending → cash) has NO backend route — the spending balance is
+ * receive-only, exactly as in the web app (AccountTransferFlow) — so we offer
+ * only the inbound transfer and don't fabricate a withdraw.
+ */
+export declare function registerSpending(program: Command): void;

package/dist/cli/perfolio-commands/trade.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTrade(program: Command): void;

package/dist/cli/perfolio-commands/tx.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTx(program: Command): void;

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

@@ -0,0 +1,78 @@
+import type { TokenHolder } from "./auth-session.js";
+export interface AgentClientOpts {
+    agent: string;
+    /** Shared holder of the perfolio access JWT + refresh (drives refresh-on-401). */
+    auth?: TokenHolder;
+    fetchImpl?: typeof fetch;
+}
+export declare class AgentClient {
+    private base;
+    private auth?;
+    private f;
+    constructor(opts: AgentClientOpts);
+    get connected(): boolean;
+    private request;
+    /**
+     * Spendable funds + session state. Hits `GET /balance` (api-key auth), which
+     * returns the credit-aware status shape (active + USDC/USDT, not_set_up,
+     * credit_exhausted, or sign-up credit). NOT `/me` — that route is JWT-only and
+     * carries identity, not funds.
+     */
+    balance(): Promise<Record<string, unknown>>;
+    /**
+     * The chain-agnostic spendable split — sign-up free credit + funds you added +
+     * total. Hits `GET /credit` (dual-auth, so the api-key works). This is the same
+     * figure the app shows on the Spending screen; `balance()` (/balance) carries
+     * the session status, so the portfolio uses both.
+     */
+    credit(): Promise<Record<string, unknown>>;
+    /**
+     * Find a payable endpoint in the curated catalog. Hits `GET /marketplace/x402`
+     * (the grouped, public catalog route) — NOT `/marketplace`, which does not
+     * exist on the backend.
+     */
+    search(query: string, limit?: number): Promise<Record<string, unknown>>;
+    /** Exact pay contract (requestSchema) for a URL — no spend. */
+    check(url: string): Promise<Record<string, unknown>>;
+    /** Recent transactions, newest first. */
+    transactions(limit?: number): Promise<Record<string, unknown>>;
+    /** One transaction by id. */
+    tx(id: string): Promise<Record<string, unknown>>;
+    /** Exact POST /x402/pay contract for a catalog entry by slug (requestSchema + price). No spend. */
+    schema(slug: string): Promise<Record<string, unknown>>;
+    /** Ingest any x402 origin's endpoints into the catalog so they become searchable/payable. */
+    discover(origin: string): Promise<Record<string, unknown>>;
+    /** Claim an invite / bonus credit by code. Mints or tops up the session's spendable funds. */
+    redeem(code: string): Promise<Record<string, unknown>>;
+    /** One-time link (+ code) to secure a full account and add funds. Gated by the session key. */
+    linkCode(): Promise<{
+        url: string;
+        code: string;
+        expiresAt: number;
+    }>;
+    /**
+     * Pay + run an endpoint via the session. Body matches `POST /x402/pay`'s
+     * schema: `method` is required (uppercased), `expectedPriceMinor` (the spend
+     * cap) and `asset` are required, and `body` is a RAW STRING passthrough — not
+     * a parsed object. The agent never signs; the session owns the spend.
+     */
+    fetchPay(b: {
+        url: string;
+        method: string;
+        expectedPriceMinor: string;
+        asset: string;
+        body?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Gasless transfer to an address. Hits `POST /transactions` (there is no
+     * `/transfer` route); body is `{ asset, amount, recipient }` where `amount` is
+     * the minor-units decimal string.
+     */
+    transfer(b: {
+        recipient: string;
+        amount: string;
+        asset: string;
+    }): Promise<Record<string, unknown>>;
+    /** Stop all spend on this key — revoke the session (terminal). */
+    revoke(): Promise<Record<string, unknown>>;
+}

package/dist/lib/amounts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validate a human decimal amount without converting it. The Perfolio backend
+ * accepts decimal strings directly (it runs parseUnits server-side), so the
+ * CLI must NOT pre-convert to base units — passing base units would be
+ * misread by the Enso heuristic. This gives the same early "too many decimal
+ * places" feedback toBaseUnits would, then returns the trimmed decimal string.
+ */
+export declare function assertDecimal(value: string, decimals: number): string;
+/** Convert a human decimal string to integer base units (no floats). */
+export declare function toBaseUnits(value: string, decimals: number): string;
+/** Convert integer base units back to a trimmed decimal string. */
+export declare function fromBaseUnits(base: string, decimals: number): string;
+/** Friendly display. Cash renders as currency; other assets as "<n> <friendly>". */
+export declare function formatAmount(base: string, decimals: number, friendly: string): string;

package/dist/lib/assets.d.ts

@@ -0,0 +1,12 @@
+import type { AssetDto, ResolvedAsset } from './types.js';
+export declare const FRIENDLY_TERMS: readonly ["gold", "cash", "bitcoin", "ethereum"];
+export declare class AssetResolver {
+    private byFriendly;
+    private friendlyBySymbol;
+    constructor(assets: AssetDto[]);
+    resolve(input: string): ResolvedAsset;
+    /** Friendly word for a backend symbol; falls back to the symbol itself. */
+    label(symbol: string): string;
+    /** True when a backend symbol maps to a v1 friendly term (canonical asset). */
+    isFriendly(symbol: string): boolean;
+}

package/dist/lib/auth-session.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Unified-auth shared token holder.
+ *
+ * `grant login` mints ONE perfolio-signed access JWT; both backend clients
+ * (money + agent) send it as `Authorization: Bearer`. A single {@link TokenHolder}
+ * owns that JWT and the opaque `pfr_` refresh token, so a 401 from EITHER backend
+ * refreshes once and BOTH clients pick up the new JWT.
+ *
+ * The refresh is single-flight (concurrent 401s coalesce into one network call)
+ * and stale-aware ({@link TokenHolder.refreshIfStale}): a client that 401s with a
+ * token another client has already rotated past just uses the current token
+ * instead of spending the (rotating) refresh token a second time.
+ */
+export interface RefreshedTokens {
+    accessJwt: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+/** Exchanges the current `pfr_` refresh token for a fresh access JWT (+ rotated refresh). */
+export type RefreshFn = (refreshToken: string) => Promise<RefreshedTokens>;
+export interface TokenHolderOpts {
+    accessJwt?: string;
+    refreshToken?: string;
+    refresh: RefreshFn;
+    /** Persist rotated tokens back to disk so the refresh survives across invocations. */
+    onRefresh?: (tokens: RefreshedTokens) => void;
+}
+export declare class TokenHolder {
+    private accessJwt?;
+    private refreshToken?;
+    private readonly doRefresh;
+    private readonly onRefresh?;
+    /** The in-flight refresh, if any — coalesces concurrent callers (single-flight). */
+    private inFlight?;
+    constructor(opts: TokenHolderOpts);
+    /** The current access JWT to send as `Authorization: Bearer`. */
+    get token(): string | undefined;
+    /**
+     * Refresh only if the caller's token is still the live one. If another client
+     * already rotated the token (current !== usedToken), return the current token
+     * without a second refresh — the caller should just retry with it.
+     */
+    refreshIfStale(usedToken?: string): Promise<string | undefined>;
+    /**
+     * Rotate the access JWT via the refresh token. Single-flight: concurrent calls
+     * share one network round-trip. Returns the new JWT, or `undefined` if there is
+     * no refresh token or the refresh failed (the old token is left in place).
+     */
+    refresh(): Promise<string | undefined>;
+}
+/**
+ * `POST {api}/cli/token/refresh` — exchange a `pfr_` refresh token for a fresh
+ * perfolio access JWT. Per CONTRACT v1 the payload is `{ accessJwt, refreshToken,
+ * expiresAt }`; it arrives inside perfolio's standard `{ success, data }` envelope.
+ * The legacy `token` field is accepted as a fallback during the migration window.
+ */
+export declare function refreshAccessToken(api: string, refreshToken: string, f?: typeof fetch): Promise<RefreshedTokens>;