@pollar/core 0.8.2 → 0.9.0-rc.1

package/dist/index.d.ts

@@ -1,8 +1,36 @@
 import { S as Storage, O as OnStorageDegrade } from './types-DqgJIJBl.js';
 export { a as StorageDegradeReason } from './types-DqgJIJBl.js';
-import { V as VisibilityProvider } from './types-84G_htcn.js';
+import { V as VisibilityProvider } from './types-Dyky8g0p.js';
 import * as openapi_fetch from 'openapi-fetch';
 
+/**
+ * Log levels in increasing verbosity. Setting a level emits that level and
+ * every more-important one; `silent` disables all SDK logging.
+ *
+ *   silent < error < warn < info < debug
+ */
+type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Sink the SDK writes logs to. The global `console` already satisfies this
+ * shape, so it's the default. Inject your own (pino, Sentry breadcrumbs, a test
+ * spy…) via `PollarClientConfig.logger` to route SDK logs wherever you want.
+ */
+interface PollarLogger {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}
+/**
+ * Build a level-gated logger over a sink. The returned object has the same
+ * method surface as {@link PollarLogger}; each call is silently dropped when its
+ * level is more verbose than the configured `level`. Messages keep their own
+ * `[PollarClient…]` prefixes, so this only adds filtering + sink routing.
+ *
+ * Defaults: `level = 'info'`, `sink = console`.
+ */
+declare function createLogger(level?: LogLevel, sink?: PollarLogger): PollarLogger;
+
 type StellarNetwork = 'mainnet' | 'testnet';
 type StellarClientConfig = StellarNetwork | {
     horizonUrl: string;
@@ -90,7 +118,6 @@ declare enum WalletType {
 type WalletId = WalletType | (string & {});
 interface ConnectWalletResponse {
     address: string;
-    publicKey: string;
 }
 interface SignTransactionOptions {
     network?: string;
@@ -133,14 +160,23 @@ declare class FreighterAdapter implements WalletAdapter {
     signAuthEntry(entryXdr: string, options?: SignAuthEntryOptions): Promise<SignAuthEntryResponse>;
 }
 
+/** Albedo's own network vocabulary (it only understands these two values). */
+type AlbedoNetwork = 'public' | 'testnet';
 declare class AlbedoAdapter implements WalletAdapter {
+    private readonly network;
     readonly type = WalletType.ALBEDO;
+    /**
+     * Network used for `connect` and `signAuthEntry` (which carry no per-call
+     * network) and as the fallback for `signTransaction`. Defaults to `'testnet'`
+     * to preserve the previous behavior when constructed with no argument.
+     */
+    constructor(network?: AlbedoNetwork);
     isAvailable(): Promise<boolean>;
     connect(): Promise<ConnectWalletResponse>;
     disconnect(): Promise<void>;
     getPublicKey(): Promise<string | null>;
     getNetwork(): Promise<string>;
-    signTransaction(xdr: string, _options?: SignTransactionOptions): Promise<SignTransactionResponse>;
+    signTransaction(xdr: string, options?: SignTransactionOptions): Promise<SignTransactionResponse>;
     signAuthEntry(entryXdr: string, _options?: SignAuthEntryOptions): Promise<SignAuthEntryResponse>;
 }
 
@@ -165,9 +201,13 @@ interface PollarPersistedSession {
         ready: boolean;
     };
     wallet: {
-        publicKey: string | null;
+        type: 'custodial' | 'smart' | 'external';
+        address: string | null;
         existsOnStellar?: boolean;
         createdAt?: number;
+        linkedAt?: number;
+        network?: string;
+        deployTxHash?: string | null;
     };
 }
 /** In-memory user profile (kept on `PollarClient`, never persisted). */
@@ -203,9 +243,22 @@ interface PollarClientConfig {
     storage?: Storage;
     /**
      * Pluggable DPoP key manager. Defaults to `defaultKeyManager(storage,
-     * apiKeyHash)`: WebCrypto in browsers, `@noble/curves` in RN.
+     * apiKey)`: WebCrypto in browsers, `@noble/curves` in RN.
      */
     keyManager?: KeyManager;
+    /**
+     * Minimum severity the SDK logs. `silent` disables all SDK logging; the rest
+     * emit that level and everything more important (`error` < `warn` < `info` <
+     * `debug`). State-transition chatter (auth/tx/network) is at `debug`.
+     * Defaults to `'info'`.
+     */
+    logLevel?: LogLevel;
+    /**
+     * Sink the SDK writes logs to. Defaults to the global `console`. Inject your
+     * own (pino, Sentry breadcrumbs, a test spy…) to route SDK logs anywhere.
+     * Filtering by `logLevel` still applies on top of whatever you pass.
+     */
+    logger?: PollarLogger;
     /**
      * Notified when persistent storage silently degrades to in-memory mode
      * (Safari private browsing quota errors, sandboxed iframes, etc.). Useful
@@ -242,7 +295,8 @@ interface PollarClientConfig {
      * the moment visibility comes back. Defaults to a web provider in the
      * browser (`visibilitychange` + BFCache + focus) and a noop elsewhere.
      * React Native consumers should inject an `AppState`-backed provider —
-     * see TODO on `VisibilityProvider`.
+     * use `createAppStateVisibilityProvider` from
+     * `@pollar/core/adapters/react-native-appstate`.
      */
     visibilityProvider?: VisibilityProvider;
     /**
@@ -271,7 +325,55 @@ interface PollarClientConfig {
      * same URL you pass to `WebBrowser.openAuthSessionAsync`.
      */
     oauthRedirectUri?: string;
+    /**
+     * The passkey (WebAuthn) ceremony for "Smart Wallet" login, injected by the
+     * runtime layer (`@pollar/react` implements it with `@simplewebauthn/browser`).
+     * `@pollar/core` stays runtime-agnostic and never touches `navigator.credentials`
+     * directly. Required to use `loginSmartWallet()`. Browser-only for now;
+     * React Native needs a native passkey provider.
+     */
+    passkey?: PasskeyCeremony;
+    /**
+     * Signs smart-account (C-address) transactions with the user's passkey.
+     * Required to send from a smart wallet. Injected by `@pollar/react`;
+     * browser-only for now.
+     */
+    passkeySign?: PasskeySigner;
 }
+/**
+ * Runs the device WebAuthn ceremony for a server-issued challenge and returns
+ * the result to forward to the backend: a registration response for a new user
+ * (`create()`) or an authentication assertion for a returning one (`get()`).
+ * The implementation decides which (e.g. try `get()` first, fall back to
+ * `create()`). `response` is the browser's PublicKeyCredential serialized to
+ * JSON — forwarded verbatim to `/auth/passkey/{register,login}`.
+ */
+type PasskeyCeremony = (ctx: {
+    challenge: string;
+}) => Promise<{
+    kind: 'login';
+    response: unknown;
+} | {
+    kind: 'register';
+    response: unknown;
+}>;
+/**
+ * Signs a smart-account transaction's auth digest with the user's passkey
+ * (a WebAuthn `get()` whose challenge is the raw digest). Returns the PUBLIC
+ * assertion fields (base64url) for the server to assemble into the Soroban auth
+ * entry — no secret leaves the device. Injected by the runtime layer
+ * (`@pollar/react`); `@pollar/core` never touches `navigator.credentials`.
+ */
+type PasskeySigner = (ctx: {
+    /** base64url WebAuthn credential id to sign with. */
+    credentialId: string;
+    /** hex-encoded auth digest to use as the WebAuthn challenge. */
+    challenge: string;
+}) => Promise<{
+    authenticatorData: string;
+    clientDataJSON: string;
+    signature: string;
+}>;
 /**
  * Strategy for opening the hosted OAuth URL. The SDK mints the per-login auth
  * session lazily inside `getUrl()` (call it once; the first call creates the
@@ -310,6 +412,23 @@ interface SessionInfo {
     current: boolean;
     expiresAt: string;
 }
+/**
+ * Observable state for the active-sessions list. Lives on the client (like
+ * {@link TxHistoryState} / {@link WalletBalanceState}) so UI layers can
+ * subscribe via `onSessionsStateChange` and stay pure readers instead of
+ * holding the loading state locally.
+ */
+type SessionsState = {
+    step: 'idle';
+} | {
+    step: 'loading';
+} | {
+    step: 'loaded';
+    sessions: SessionInfo[];
+} | {
+    step: 'error';
+    message: string;
+};
 type TxBuildBody = NonNullable<paths['/tx/build']['post']['requestBody']>['content']['application/json'];
 type TxBuildResponse = paths['/tx/build']['post']['responses'][200]['content']['application/json'];
 type TxSignAndSendBody = NonNullable<paths['/tx/sign-and-send']['post']['requestBody']>['content']['application/json'];
@@ -451,6 +570,7 @@ declare const AUTH_ERROR_CODES: {
     readonly WALLET_CONNECT_FAILED: "WALLET_CONNECT_FAILED";
     readonly WALLET_AUTH_FAILED: "WALLET_AUTH_FAILED";
     readonly WALLET_RESOLVER_TIMEOUT: "WALLET_RESOLVER_TIMEOUT";
+    readonly PASSKEY_FAILED: "PASSKEY_FAILED";
     readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR";
 };
 type AuthErrorCode = (typeof AUTH_ERROR_CODES)[keyof typeof AUTH_ERROR_CODES];
@@ -483,11 +603,21 @@ type AuthState = {
     walletType: WalletId;
 } | {
     step: 'authenticating_wallet';
+} | {
+    step: 'creating_passkey';
+} | {
+    step: 'deploying_smart_account';
 } | {
     step: 'authenticating';
 } | {
     step: 'authenticated';
     session: PollarPersistedSession;
+    /**
+     * `false` while the session is restored optimistically from storage and
+     * not yet revalidated with the server; `true` after a fresh login/refresh
+     * or a successful `/auth/session/resume`. Gate sensitive actions on this.
+     */
+    verified: boolean;
 } | {
     step: 'error';
     previousStep: string;
@@ -519,6 +649,19 @@ type WalletBalanceState = {
     step: 'error';
     message: string;
 };
+type WalletAssetsContent = paths['/wallet/assets']['get']['responses'][200]['content']['application/json']['content'];
+type EnabledAssetRecord = WalletAssetsContent['assets'][number];
+type EnabledAssetsState = {
+    step: 'idle';
+} | {
+    step: 'loading';
+} | {
+    step: 'loaded';
+    data: WalletAssetsContent;
+} | {
+    step: 'error';
+    message: string;
+};
 type TxHistoryRecord = paths['/tx/history']['get']['responses'][200]['content']['application/json']['content']['records'][number];
 type TxHistoryParams = NonNullable<paths['/tx/history']['get']['parameters']['query']>;
 type TxHistoryContent = paths['/tx/history']['get']['responses'][200]['content']['application/json']['content'];
@@ -581,6 +724,7 @@ declare class PollarClient {
     readonly id: string;
     readonly basePath: string;
     private readonly _api;
+    private readonly _log;
     private readonly _storage;
     private readonly _keyManager;
     /** Resolves once `keyManager.init()` and the initial session restore complete. */
@@ -625,8 +769,12 @@ declare class PollarClient {
     private _transactionStateListeners;
     private _txHistoryState;
     private _txHistoryStateListeners;
+    private _sessionsState;
+    private _sessionsStateListeners;
     private _walletBalanceState;
     private _walletBalanceStateListeners;
+    private _enabledAssetsState;
+    private _enabledAssetsStateListeners;
     private _authState;
     private _authStateListeners;
     private _networkState;
@@ -643,7 +791,11 @@ declare class PollarClient {
     private _walletAdapter;
     private readonly _walletAdapterResolver;
     private readonly _walletResolverTimeoutMs;
+    private readonly _passkey;
+    private readonly _passkeySign;
     private _loginController;
+    /** Aborts an in-flight `/auth/session/resume` on destroy() or re-trigger. */
+    private _resumeController;
     /** Platform strategy for opening the hosted-OAuth URL (popup on web; injected on RN). */
     private readonly _openAuthUrl;
     /** `redirect_uri` sent to the backend for hosted OAuth. */
@@ -718,6 +870,12 @@ declare class PollarClient {
     sendEmailCode(email: string): void;
     verifyEmailCode(code: string): void;
     loginWallet(type: WalletId): void;
+    /**
+     * "Smart Wallet" login: runs the passkey (WebAuthn) ceremony and, for a new
+     * user, creates a sponsored smart-account C-address. Requires the `passkey`
+     * ceremony to be configured (e.g. via `@pollar/react`).
+     */
+    loginSmartWallet(): void;
     cancelLogin(): void;
     /**
      * Revoke the current session server-side, then clear local storage.
@@ -741,6 +899,14 @@ declare class PollarClient {
      * `current` flag identifies which entry corresponds to this client.
      */
     listSessions(): Promise<SessionInfo[]>;
+    getSessionsState(): SessionsState;
+    onSessionsStateChange(cb: (state: SessionsState) => void): () => void;
+    /**
+     * Fire-and-forget variant of {@link listSessions} that drives the observable
+     * `SessionsState` store instead of returning the array. UI layers subscribe
+     * via `onSessionsStateChange` and stay pure readers — mirrors `fetchTxHistory`.
+     */
+    fetchSessions(): Promise<void>;
     /**
      * Revoke a specific refresh-token family (a single device session). Use
      * `listSessions` to enumerate the familyIds. Revoking the current session
@@ -749,6 +915,12 @@ declare class PollarClient {
     revokeSession(familyId: string): Promise<void>;
     getNetwork(): StellarNetwork;
     getNetworkState(): NetworkState;
+    /**
+     * The client's level-gated logger (built from `logLevel` / `logger`). Exposed
+     * so the runtime layer (`@pollar/react`) can route its own logs through the
+     * same level and sink instead of calling `console` directly.
+     */
+    getLogger(): PollarLogger;
     setNetwork(network: StellarNetwork): void;
     onNetworkStateChange(cb: (state: NetworkState) => void): () => void;
     getTransactionState(): TransactionState | null;
@@ -758,7 +930,28 @@ declare class PollarClient {
     fetchTxHistory(params?: TxHistoryParams): Promise<void>;
     getWalletBalanceState(): WalletBalanceState;
     onWalletBalanceStateChange(cb: (state: WalletBalanceState) => void): () => void;
-    refreshBalance(publicKey?: string): Promise<void>;
+    /**
+     * Refreshes the balances of the authenticated user's OWN wallet. The wallet
+     * and network are resolved server-side from the session — no arguments. Drives
+     * `walletBalanceState`. For an arbitrary wallet, use {@link getWalletBalance}.
+     */
+    refreshBalance(): Promise<void>;
+    /**
+     * General-purpose balance lookup for ANY wallet on ANY network — not scoped
+     * to this application. Enumerates the account's real on-chain holdings via
+     * Horizon (server-side) and returns the data directly (no reactive state).
+     * `network` defaults to the client's current network.
+     */
+    getWalletBalance(publicKey: string, network?: StellarNetwork): Promise<WalletBalanceContent>;
+    getEnabledAssetsState(): EnabledAssetsState;
+    onEnabledAssetsStateChange(cb: (state: EnabledAssetsState) => void): () => void;
+    /**
+     * Loads the application's enabled assets paired with the authenticated
+     * wallet's on-chain trustline state — so the SDK knows which trustlines still
+     * need to be added. Wallet and network are resolved server-side from the
+     * session. Drives `enabledAssetsState`; mirrors {@link refreshBalance}.
+     */
+    refreshAssets(): Promise<void>;
     /**
      * Builds an unsigned XDR. Drives `_setTransactionState` for modal-style UIs
      * AND returns a {@link BuildOutcome} so headless callers can `await` and
@@ -813,7 +1006,7 @@ declare class PollarClient {
      *   backend call) and then transitions to `submitted` (Horizon ack only) or
      *   `success` (ledger-confirmed), or `error[phase: 'signing-submitting']`.
      */
-    signAndSubmitTx(unsignedXdr: string): Promise<SubmitOutcome>;
+    signAndSubmitTx(unsignedXdr?: string): Promise<SubmitOutcome>;
     /**
      * One-shot: build → sign → submit, returning the final {@link SubmitOutcome}.
      *
@@ -834,6 +1027,20 @@ declare class PollarClient {
     buildAndSignAndSubmitTx(operation: TxBuildBody['operation'], params: TxBuildBody['params'], options?: TxBuildBody['options']): Promise<SubmitOutcome>;
     /** Alias for {@link buildAndSignAndSubmitTx} — shorter "just do the thing" name. */
     runTx(operation: TxBuildBody['operation'], params: TxBuildBody['params'], options?: TxBuildBody['options']): Promise<SubmitOutcome>;
+    /**
+     * Smart-wallet (passkey / C-address) transaction: build (server prepares the
+     * SAC transfer + returns the auth digest) → sign the digest with the passkey
+     * → submit (server assembles the signed auth entry and broadcasts; the
+     * sponsor pays the fee). State machine: building → built → signing →
+     * submitting → success.
+     */
+    private _runSmartTx;
+    /**
+     * Steps 2–3 of the smart-wallet flow: sign the prepared auth digest with the
+     * passkey, then submit. Shared by `_runSmartTx` (atomic) and `signAndSubmitTx`
+     * (split flow, when a smart build is already on the state machine).
+     */
+    private _signSubmitSmart;
     getAppConfig(): Promise<unknown>;
     getKycStatus(providerId?: string): Promise<{
         status: KycStatus;
@@ -871,7 +1078,9 @@ declare class PollarClient {
     listDistributionRules(): Promise<DistributionRule[]>;
     claimDistributionRule(body: DistributionClaimBody): Promise<DistributionClaimContent>;
     private _setTxHistoryState;
+    private _setSessionsState;
     private _setWalletBalanceState;
+    private _setEnabledAssetsState;
     private _newController;
     private _flowDeps;
     /**
@@ -883,6 +1092,21 @@ declare class PollarClient {
     private _resolveWalletAdapter;
     private _handleFlowError;
     private _restoreSession;
+    /**
+     * Validate the restored session against the server and repopulate the
+     * in-memory profile (PII is never persisted, so it's null after a cold
+     * reload). Goes through the normal authed client, so it coalesces with any
+     * in-flight refresh (onRequest awaits `_refreshPromise`) and, being a GET,
+     * is auto-retried after a 401-triggered refresh.
+     *
+     * - 200          → store profile, mark the session `verified`.
+     * - 401          → the refresh-on-401 path already ran; if the family was
+     *                  revoked, refresh failed and `_clearSession()` took us to
+     *                  idle. Nothing to do here — don't double-handle.
+     * - network error → stay optimistic (do NOT log out); revalidated later on
+     *                  `visibilitychange` or first use.
+     */
+    private _resume;
     private _storeSession;
     private _clearSession;
     private _networkPassphrase;
@@ -898,6 +1122,16 @@ declare class PollarClient {
     private _currentBuildData;
 }
 
+/**
+ * Version of this `@pollar/core` build (e.g. `'0.8.2'`). Falls back to `'dev'`
+ * when running unbundled.
+ *
+ * Named per-package on purpose: importing it alongside `@pollar/react`'s
+ * `POLLAR_REACT_VERSION` never collides, so an app can report both versions in
+ * a single bug-report / diagnostics line.
+ */
+declare const POLLAR_CORE_VERSION: string;
+
 /**
  * In-memory storage backed by a `Map`. Always available, never throws.
  * Used as the default fallback for SSR, private browsing, sandboxed iframes
@@ -911,6 +1145,11 @@ interface LocalStorageAdapterOptions {
      * in-memory fallback (e.g. quota exceeded, throwing `localStorage`).
      */
     onDegrade?: OnStorageDegrade;
+    /**
+     * Logger for the one-shot degrade warning. Defaults to the global `console`;
+     * `PollarClient` passes its level-gated logger so `logLevel` applies here too.
+     */
+    logger?: PollarLogger;
 }
 /**
  * `localStorage`-backed adapter that wraps every operation in try/catch and
@@ -968,6 +1207,20 @@ declare class WebCryptoKeyManager implements KeyManager {
      */
     init(): Promise<void>;
     private _doInit;
+    /**
+     * Derive the public JWK from a `CryptoKey`. Prefers the `'raw'` export (the
+     * 65-byte uncompressed point `0x04 || X(32) || Y(32)`) and base64url-encodes
+     * the coordinates ourselves — that sidesteps polyfills whose `exportKey('jwk')`
+     * emits non-base64url `x`/`y` (standard base64, `=` padding, or — as seen with
+     * `react-native-quick-crypto` — a stray `.`). Real browsers and most polyfills
+     * support `'raw'` for public EC keys.
+     *
+     * Falls back to the `'jwk'` export (normalized via `canonicalEcJwk`) if `'raw'`
+     * is unsupported or returns an unexpected shape, so this can't regress on a
+     * runtime that only implements the JWK path. Both routes yield identical
+     * coordinate bytes, so the `cnf.jkt` thumbprint is unchanged either way.
+     */
+    private _exportPublicJwk;
     reset(): Promise<void>;
     getPublicJwk(): Promise<PublicEcJwk>;
     getThumbprint(): Promise<string>;
@@ -995,9 +1248,11 @@ declare class WebCryptoKeyManager implements KeyManager {
  */
 declare function computeJwkThumbprint(jwk: PublicEcJwk): Promise<string>;
 /**
- * Strip a JWK to only the four required EC public members. Useful when the
- * input came from `crypto.subtle.exportKey('jwk', publicKey)` which adds
- * `ext` / `key_ops`. Returns a fresh object — never mutates input.
+ * Strip a JWK to only the four required EC public members and normalize the
+ * coordinates to unpadded base64url. Useful when the input came from
+ * `crypto.subtle.exportKey('jwk', publicKey)` which adds `ext` / `key_ops`
+ * (and, under some RN polyfills, non-base64url coordinates). Returns a fresh
+ * object — never mutates input.
  */
 declare function canonicalEcJwk(jwk: {
     kty?: string;
@@ -1265,6 +1520,66 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/auth/passkey/challenge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Issue a WebAuthn challenge
+         * @description Returns a server challenge bound to the client session for the create()/get() ceremony.
+         */
+        post: operations["postAuthPasskeyChallenge"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/passkey/register": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Register a passkey and create a Smart Wallet
+         * @description Verifies the WebAuthn registration, creates the user, deploys the smart-account C-address (sponsored), and sets the session ready.
+         */
+        post: operations["postAuthPasskeyRegister"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/passkey/login": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Authenticate a returning passkey user
+         * @description Verifies the WebAuthn assertion against the stored credential, resolves the C-address, sets the session ready.
+         */
+        post: operations["postAuthPasskeyLogin"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/auth/login": {
         parameters: {
             query?: never;
@@ -1345,6 +1660,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/auth/session/resume": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Validate the current session and return the user profile
+         * @description DPoP-bound resume/validate + touch. Confirms the refresh-token family is still active, returns the same profile shape as login `data` (mail, names, avatar, providers), and records the return (last_used_at + UA/IP-hash). Does NOT rotate the refresh token or create a new family. A revoked/expired family returns 401 so the client can converge to a logged-out state.
+         */
+        get: operations["getAuthSessionResume"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/auth/sessions/{familyId}": {
         parameters: {
             query?: never;
@@ -1590,8 +1925,8 @@ interface paths {
             cookie?: never;
         };
         /**
-         * Get wallet balances
-         * @description Returns XLM and configured asset balances for a Stellar account using Soroban RPC (no Horizon). The asset list is derived from the application's enabled assets. "available" reflects the spendable amount after minimum reserve (XLM) and selling liabilities.
+         * Get my wallet balances
+         * @description Returns XLM and the application's enabled-asset balances for the authenticated user's wallet using Soroban RPC (no Horizon). The wallet and network are derived from the session — no parameters required. "available" reflects the spendable amount after minimum reserve (XLM) and selling liabilities.
          */
         get: operations["getWalletBalance"];
         put?: never;
@@ -1602,6 +1937,46 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/wallet/assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get my enabled assets
+         * @description Returns the application's dashboard-enabled assets paired with the authenticated wallet's on-chain trustline state (code, type, issuer, name, trustlineEstablished, limit). No balances. Native XLM is always included with trustlineEstablished=true. Lets the SDK know which trustlines the wallet still needs to add. The wallet and network are derived from the session — no parameters required.
+         */
+        get: operations["getWalletAssets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/{publicKey}/balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get any wallet balances
+         * @description Returns the real on-chain balances of any Stellar account on the requested network, enumerated via Horizon. Not scoped to the application — every established trustline (native included) is returned.
+         */
+        get: operations["getWalletByPublicKeyBalance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/kyc/status": {
         parameters: {
             query?: never;
@@ -2478,7 +2853,7 @@ interface operations {
             };
         };
     };
-    postAuthLogin: {
+    postAuthPasskeyChallenge: {
         parameters: {
             query?: never;
             header?: never;
@@ -2489,20 +2864,11 @@ interface operations {
             content: {
                 "application/json": {
                     clientSessionId: string;
-                    dpopJwk?: {
-                        /** @constant */
-                        kty: "EC";
-                        /** @constant */
-                        crv: "P-256";
-                        x: string;
-                        y: string;
-                    };
-                    deviceLabel?: string;
                 };
             };
         };
         responses: {
-            /** @description Authenticated */
+            /** @description Challenge issued */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2510,47 +2876,12 @@ interface operations {
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_LOGIN_SUCCESS";
+                        code: "SDK_PASSKEY_CHALLENGE_CREATED";
                         /** @constant */
                         success: true;
                         content: {
                             clientSessionId: string;
-                            userId: string | null;
-                            status: string;
-                            token: {
-                                accessToken: string;
-                                refreshToken: string;
-                                expiresAt: number;
-                            };
-                            user: {
-                                id?: string;
-                                ready: boolean;
-                            };
-                            wallet: {
-                                publicKey: string | null;
-                                existsOnStellar?: boolean;
-                                createdAt?: number;
-                            };
-                            data: {
-                                mail: string;
-                                first_name: string;
-                                last_name: string;
-                                avatar: string;
-                                providers: {
-                                    email: {
-                                        address: string;
-                                    } | null;
-                                    google: {
-                                        id: string;
-                                    } | null;
-                                    github: {
-                                        id: string;
-                                    } | null;
-                                    wallet: {
-                                        address: string;
-                                    } | null;
-                                };
-                            };
+                            challenge: string;
                         };
                     };
                 };
@@ -2622,7 +2953,7 @@ interface operations {
             };
         };
     };
-    postAuthRefresh: {
+    postAuthPasskeyRegister: {
         parameters: {
             query?: never;
             header?: never;
@@ -2632,12 +2963,15 @@ interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    refreshToken: string;
+                    clientSessionId: string;
+                    response: {
+                        [key: string]: unknown;
+                    };
                 };
             };
         };
         responses: {
-            /** @description New token pair issued */
+            /** @description Passkey registered, smart wallet created */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2645,15 +2979,12 @@ interface operations {
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_TOKEN_REFRESHED";
+                        code: "SDK_PASSKEY_REGISTERED";
                         /** @constant */
                         success: true;
                         content: {
-                            token: {
-                                accessToken: string;
-                                refreshToken: string;
-                                expiresAt: number;
-                            };
+                            clientSessionId: string;
+                            contractAddress: string;
                         };
                     };
                 };
@@ -2725,7 +3056,7 @@ interface operations {
             };
         };
     };
-    postAuthLogout: {
+    postAuthPasskeyLogin: {
         parameters: {
             query?: never;
             header?: never;
@@ -2735,12 +3066,15 @@ interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    everywhere?: boolean;
+                    clientSessionId: string;
+                    response: {
+                        [key: string]: unknown;
+                    };
                 };
             };
         };
         responses: {
-            /** @description Sessions revoked */
+            /** @description Passkey authenticated */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2748,17 +3082,18 @@ interface operations {
                 content: {
                     "application/json": {
                         /** @constant */
-                        code: "SDK_LOGOUT_SUCCESS";
+                        code: "SDK_PASSKEY_AUTHENTICATED";
                         /** @constant */
                         success: true;
                         content: {
-                            revoked: number;
+                            clientSessionId: string;
+                            contractAddress: string;
                         };
                     };
                 };
             };
-            /** @description Unauthorized */
-            401: {
+            /** @description Validation error */
+            400: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2770,14 +3105,366 @@ interface operations {
                     };
                 };
             };
-        };
-    };
-    getAuthSessions: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Gone (expired) */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    postAuthLogin: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    clientSessionId: string;
+                    dpopJwk?: {
+                        /** @constant */
+                        kty: "EC";
+                        /** @constant */
+                        crv: "P-256";
+                        x: string;
+                        y: string;
+                    };
+                    deviceLabel?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Authenticated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_LOGIN_SUCCESS";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            clientSessionId: string;
+                            userId: string | null;
+                            status: string;
+                            token: {
+                                accessToken: string;
+                                refreshToken: string;
+                                expiresAt: number;
+                            };
+                            user: {
+                                id?: string;
+                                ready: boolean;
+                            };
+                            wallet: {
+                                /** @enum {string} */
+                                type: "custodial" | "smart" | "external";
+                                publicKey: string | null;
+                                address: string | null;
+                                existsOnStellar?: boolean;
+                                createdAt?: number;
+                                linkedAt?: number;
+                                network?: string;
+                                deployTxHash?: string | null;
+                            };
+                            data: {
+                                mail: string;
+                                first_name: string;
+                                last_name: string;
+                                avatar: string;
+                                providers: {
+                                    email: {
+                                        address: string;
+                                    } | null;
+                                    google: {
+                                        id: string;
+                                    } | null;
+                                    github: {
+                                        id: string;
+                                    } | null;
+                                    wallet: {
+                                        address: string;
+                                    } | null;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Gone (expired) */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    postAuthRefresh: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    refreshToken: string;
+                };
+            };
+        };
+        responses: {
+            /** @description New token pair issued */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_TOKEN_REFRESHED";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            token: {
+                                accessToken: string;
+                                refreshToken: string;
+                                expiresAt: number;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Gone (expired) */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    postAuthLogout: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    everywhere?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Sessions revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_LOGOUT_SUCCESS";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            revoked: number;
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    getAuthSessions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
         requestBody?: never;
         responses: {
@@ -2822,6 +3509,64 @@ interface operations {
             };
         };
     };
+    getAuthSessionResume: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session valid; profile returned */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_SESSION_RESUMED";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            mail: string;
+                            first_name: string;
+                            last_name: string;
+                            avatar: string;
+                            providers: {
+                                email: {
+                                    address: string;
+                                } | null;
+                                google: {
+                                    id: string;
+                                } | null;
+                                github: {
+                                    id: string;
+                                } | null;
+                                wallet: {
+                                    address: string;
+                                } | null;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
     deleteAuthSessionsByFamilyId: {
         parameters: {
             query?: never;
@@ -3008,7 +3753,8 @@ interface operations {
                 "application/json": {
                     /** @enum {string} */
                     network: "testnet" | "mainnet";
-                    publicKey: string;
+                    publicKey?: string;
+                    address?: string;
                     options?: {
                         timeoutSec?: number;
                         memo?: {
@@ -3219,7 +3965,7 @@ interface operations {
                         /** @constant */
                         success: true;
                         content: {
-                            unsignedXdr: string;
+                            unsignedXdr?: string;
                             networkPassphrase: string;
                             estimatedFee: string;
                             summary: {
@@ -3228,6 +3974,12 @@ interface operations {
                                 network: string;
                                 fee: string;
                             };
+                            smart?: {
+                                digest: string;
+                                entryXdr: string;
+                                funcXdr: string;
+                                credentialId: string;
+                            };
                         };
                     };
                 };
@@ -3285,7 +4037,8 @@ interface operations {
                 "application/json": {
                     /** @enum {string} */
                     network: "testnet" | "mainnet";
-                    publicKey: string;
+                    publicKey?: string;
+                    address?: string;
                     unsignedXdr: string;
                 };
             };
@@ -3378,7 +4131,8 @@ interface operations {
                 "application/json": {
                     /** @enum {string} */
                     network: "testnet" | "mainnet";
-                    publicKey: string;
+                    publicKey?: string;
+                    address?: string;
                     unsignedXdr: string;
                     idempotencyKey?: string;
                 };
@@ -3469,8 +4223,18 @@ interface operations {
                 "application/json": {
                     /** @enum {string} */
                     network: "testnet" | "mainnet";
-                    publicKey: string;
-                    signedXdr: string;
+                    publicKey?: string;
+                    address?: string;
+                    signedXdr?: string;
+                    smart?: {
+                        entryXdr: string;
+                        funcXdr: string;
+                        assertion: {
+                            authenticatorData: string;
+                            clientDataJSON: string;
+                            signature: string;
+                        };
+                    };
                     idempotencyKey?: string;
                 };
             };
@@ -3550,7 +4314,8 @@ interface operations {
                 "application/json": {
                     /** @enum {string} */
                     network: "testnet" | "mainnet";
-                    publicKey: string;
+                    publicKey?: string;
+                    address?: string;
                     options?: {
                         timeoutSec?: number;
                         memo?: {
@@ -4149,13 +4914,148 @@ interface operations {
         };
     };
     getWalletBalance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Account balances */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_WALLET_BALANCE";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            publicKey: string;
+                            /** @enum {string} */
+                            network: "testnet" | "mainnet";
+                            exists: boolean;
+                            balances: {
+                                /** @enum {string} */
+                                type: "native" | "credit_alphanum4" | "credit_alphanum12";
+                                code: string;
+                                issuer?: string;
+                                balance: string;
+                                available: string;
+                                limit?: string;
+                                enabledInApp: boolean;
+                                trustlineRemoved: boolean;
+                            }[];
+                        };
+                    };
+                };
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    getWalletAssets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Enabled assets with trustline state */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        code: "SDK_WALLET_ASSETS";
+                        /** @constant */
+                        success: true;
+                        content: {
+                            publicKey: string;
+                            /** @enum {string} */
+                            network: "testnet" | "mainnet";
+                            exists: boolean;
+                            assets: {
+                                /** @enum {string} */
+                                type: "native" | "credit_alphanum4" | "credit_alphanum12";
+                                code: string;
+                                issuer?: string;
+                                name?: string;
+                                trustlineEstablished: boolean;
+                                limit?: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+            /** @description Validation error */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @constant */
+                        success: false;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+    getWalletByPublicKeyBalance: {
         parameters: {
             query: {
                 network: "testnet" | "mainnet";
-                publicKey: string;
             };
             header?: never;
-            path?: never;
+            path: {
+                publicKey: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
@@ -4904,7 +5804,7 @@ interface operations {
 type PollarApiClient = ReturnType<typeof createApiClient>;
 declare function createApiClient(baseUrl: string): openapi_fetch.Client<paths, `${string}/${string}`>;
 
-declare function isValidSession(value: unknown): value is PollarPersistedSession;
+declare function isValidSession(value: unknown, logger?: PollarLogger): value is PollarPersistedSession;
 
 /**
  * GET /kyc/status
@@ -4997,4 +5897,4 @@ declare function listDistributionRules(api: PollarApiClient): Promise<Distributi
  */
 declare function claimDistributionRule(api: PollarApiClient, body: DistributionClaimBody): Promise<DistributionClaimContent>;
 
-export { AUTH_ERROR_CODES, type AdapterFn, AlbedoAdapter, type AuthErrorCode, type AuthOpenContext, type AuthState, type AuthUrlOpener, type BuildOutcome, type BuildProofArgs, type ConnectWalletResponse, type DistributionClaimBody, type DistributionClaimContent, type DistributionRule, type DistributionRulesState, FreighterAdapter, type KeyManager, type KycFlow, type KycLevel, type KycProvider, type KycStartBody, type KycStartResponse, type KycStatus, type LocalStorageAdapterOptions, type NetworkState, OnStorageDegrade, type PaymentInstructions, type PollarAdapter, type PollarAdapters, type PollarApiClient, type PollarApplicationConfigContent, type PollarApplicationConfigResponse, PollarClient, type PollarClientConfig, PollarFlowError, type PollarLoginOptions, type PollarPersistedSession, type PollarUserProfile, type PublicEcJwk, type RampDirection, type RampQuote, type RampTxStatus, type RampsOfframpBody, type RampsOfframpResponse, type RampsOnrampBody, type RampsOnrampResponse, type RampsQuoteQuery, type RampsQuoteResponse, type RampsTransactionResponse, type RulePeriod, type SessionInfo, type SignAuthEntryOptions, type SignAuthEntryResponse, type SignOutcome, type SignTransactionOptions, type SignTransactionResponse, type StellarBalance, StellarClient, type StellarClientConfig, type StellarNetwork, Storage, type SubmitOutcome, type TransactionState, type TxBuildBody, type TxBuildContent, type TxBuildResponse, type TxBuildSignSubmitBody, type TxBuildSignSubmitContent, type TxBuildSignSubmitResponse, type TxErrorPhase, type TxHistoryContent, type TxHistoryParams, type TxHistoryRecord, type TxHistoryState, type TxSignAndSendBody, type TxSignBody, type TxSignContent, type TxSignResponse, type TxSignSendResponse, type TxSubmitSignedBody, type WalletAdapter, type WalletAdapterResolver, type WalletBalanceContent, type WalletBalanceRecord, type WalletBalanceState, type WalletId, WalletType, WebCryptoKeyManager, buildProof, canonicalEcJwk, claimDistributionRule, computeJwkThumbprint, createLocalStorageAdapter, createMemoryAdapter, createOffRamp, createOnRamp, defaultKeyManager, defaultStorage, getKycProviders, getKycStatus, getRampTransaction, getRampsQuote, isValidSession, listDistributionRules, normalizeHtu, pollKycStatus, pollRampTransaction, type paths as pollarPaths, resolveKyc, startKyc };
+export { AUTH_ERROR_CODES, type AdapterFn, AlbedoAdapter, type AuthErrorCode, type AuthOpenContext, type AuthState, type AuthUrlOpener, type BuildOutcome, type BuildProofArgs, type ConnectWalletResponse, type DistributionClaimBody, type DistributionClaimContent, type DistributionRule, type DistributionRulesState, type EnabledAssetRecord, type EnabledAssetsState, FreighterAdapter, type KeyManager, type KycFlow, type KycLevel, type KycProvider, type KycStartBody, type KycStartResponse, type KycStatus, type LocalStorageAdapterOptions, type LogLevel, type NetworkState, OnStorageDegrade, POLLAR_CORE_VERSION, type PasskeyCeremony, type PasskeySigner, type PaymentInstructions, type PollarAdapter, type PollarAdapters, type PollarApiClient, type PollarApplicationConfigContent, type PollarApplicationConfigResponse, PollarClient, type PollarClientConfig, PollarFlowError, type PollarLogger, type PollarLoginOptions, type PollarPersistedSession, type PollarUserProfile, type PublicEcJwk, type RampDirection, type RampQuote, type RampTxStatus, type RampsOfframpBody, type RampsOfframpResponse, type RampsOnrampBody, type RampsOnrampResponse, type RampsQuoteQuery, type RampsQuoteResponse, type RampsTransactionResponse, type RulePeriod, type SessionInfo, type SessionsState, type SignAuthEntryOptions, type SignAuthEntryResponse, type SignOutcome, type SignTransactionOptions, type SignTransactionResponse, type StellarBalance, StellarClient, type StellarClientConfig, type StellarNetwork, Storage, type SubmitOutcome, type TransactionState, type TxBuildBody, type TxBuildContent, type TxBuildResponse, type TxBuildSignSubmitBody, type TxBuildSignSubmitContent, type TxBuildSignSubmitResponse, type TxErrorPhase, type TxHistoryContent, type TxHistoryParams, type TxHistoryRecord, type TxHistoryState, type TxSignAndSendBody, type TxSignBody, type TxSignContent, type TxSignResponse, type TxSignSendResponse, type TxSubmitSignedBody, type WalletAdapter, type WalletAdapterResolver, type WalletAssetsContent, type WalletBalanceContent, type WalletBalanceRecord, type WalletBalanceState, type WalletId, WalletType, WebCryptoKeyManager, buildProof, canonicalEcJwk, claimDistributionRule, computeJwkThumbprint, createLocalStorageAdapter, createLogger, createMemoryAdapter, createOffRamp, createOnRamp, defaultKeyManager, defaultStorage, getKycProviders, getKycStatus, getRampTransaction, getRampsQuote, isValidSession, listDistributionRules, normalizeHtu, pollKycStatus, pollRampTransaction, type paths as pollarPaths, resolveKyc, startKyc };