@augustdigital/sdk 8.7.2 → 8.9.0

package/lib/sdk.d.ts

@@ -15111,8 +15111,268 @@ declare function assertNotStellar(address: string, operation: string): void;
  *
  * Accessible as `apiModule` on the SDK instance; the same methods are also
  * exposed directly on the SDK class.
+ *
+ * A subset of methods (loan book, risk) hit authenticated admin-only backend
+ * endpoints and require an admin-scoped August API key on the SDK
+ * constructor; each such method documents the requirement.
  */
-export declare class AugustApi {
+export declare class AugustApi extends AugustBase {
+    private headers;
+    constructor(baseConfig: IAugustBase);
+    /**
+     * Retrieve the global loan-book aggregate across every active client
+     * subaccount — one {@link ILoanBookInfo} entry per loan, with principal /
+     * interest amounts, APRs, state, and the next upcoming payment.
+     *
+     * Backed by the admin-only `GET /dashboard/loans` backend endpoint (60-second
+     * server-side cache), so the August API key configured on the SDK must
+     * belong to an admin user. Makes exactly one HTTP request and no RPC calls.
+     *
+     * @returns Array of loan-book entries; empty when there are no active loans.
+     * @throws AugustAuthError When the API key is missing or not admin-scoped.
+     * @throws AugustServerError When the API responds with a non-2xx status.
+     * @example
+     *   const loans = await sdk.apiModule.getDashboardLoans();
+     *   const active = loans.filter((l) => l.state === 'ACTIVE');
+     */
+    getDashboardLoans(): Promise<ILoanBookInfo[]>;
+    /**
+     * Retrieve every token discount-factor ladder the risk engine applies when
+     * valuing collateral.
+     *
+     * Backed by `GET /risk/discount_factors` (60-second server-side cache),
+     * which requires an authenticated August user; an admin-scoped API key
+     * works. Makes exactly one HTTP request and no RPC calls.
+     *
+     * @returns Array of {@link IDiscountFactorLadder}, one per whitelisted token that has a configured ladder.
+     * @throws AugustAuthError When the API key is missing or not authorized.
+     * @throws AugustServerError When the API responds with a non-2xx status.
+     * @example
+     *   const ladders = await sdk.apiModule.getDiscountFactors();
+     *   console.log(ladders.map((d) => `${d.address}@${d.chain}`));
+     */
+    getDiscountFactors(): Promise<IDiscountFactorLadder[]>;
+    /**
+     * Compute how much collateral a subaccount has in excess of — or is short
+     * of — what it needs to hold a target health factor, for one collateral
+     * token.
+     *
+     * Backed by `GET /risk/collateral_excess_or_deficit` (60-second server-side
+     * cache), which resolves the subaccount and reads its current health factor,
+     * so an authenticated (admin-scoped) August API key is required. Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param params.subaccount Subaccount (smart-contract wallet) address.
+     * @param params.tokenAddress Collateral token address to evaluate.
+     * @param params.tokenChain Numeric August chain id of the token (e.g. `1` for Ethereum mainnet).
+     * @param params.targetHealthFactor Health factor to solve for. Defaults server-side to the minimum healthy factor (1.2); when supplied must be a finite number greater than 0.
+     * @returns The signed excess (positive) or deficit (negative) in USD and token units. Zeroes when the subaccount has no debt.
+     * @throws AugustValidationError When an address is invalid, `tokenChain` is not an integer, or `targetHealthFactor` is out of range.
+     * @throws AugustServerError When the token has no discount factor (backend 404) or the API otherwise responds non-2xx.
+     * @example
+     *   const r = await sdk.apiModule.getCollateralExcessOrDeficit({
+     *     subaccount: '0xabc…',
+     *     tokenAddress: '0xdef…',
+     *     tokenChain: 1,
+     *   });
+     *   console.log(r.amount_usd > 0 ? 'excess' : 'deficit');
+     */
+    getCollateralExcessOrDeficit(params: {
+        subaccount: string;
+        tokenAddress: string;
+        tokenChain: number;
+        targetHealthFactor?: number;
+    }): Promise<ICollateralExcessOrDeficit>;
+    /**
+     * Simulate the collateral required to open a hypothetical loan against a
+     * chosen basket of collateral tokens.
+     *
+     * This is a pure, read-only simulation: the backend `POST
+     * /risk/collateral_simulation` endpoint (60-second server-side cache)
+     * computes required collateral and effective discount factors and changes
+     * no state. It runs against the authenticated backend, so an
+     * (admin-scoped) August API key is required. Makes exactly one HTTP request
+     * and no RPC calls.
+     *
+     * @param input Simulation parameters — see {@link ICollateralSimulationInput}. `collateral_tokens` and `collateral_token_allocation` must be non-empty and equal length; when `on_platform` is `true`, both `loan_redeployed_token_*` fields are required.
+     * @returns The simulated {@link ICollateralSimulationResults}: total debt, required collateral, resulting health factor, and a per-token breakdown.
+     * @throws AugustValidationError When addresses are invalid, `loan_amount` is not a finite non-negative number, the collateral arrays are empty / mismatched, or `on_platform` is set without redeployed-token details.
+     * @throws AugustServerError When the API responds with a non-2xx status (e.g. a token missing a discount factor).
+     * @example
+     *   const sim = await sdk.apiModule.simulateCollateral({
+     *     loan_token_chain: 1,
+     *     loan_token_address: '0xloan…',
+     *     loan_amount: 1_000_000,
+     *     collateral_tokens: [[1, '0xcol…']],
+     *     collateral_token_allocation: [1],
+     *   });
+     *   console.log(sim.total_required_collateral_usd);
+     */
+    simulateCollateral(input: ICollateralSimulationInput): Promise<ICollateralSimulationResults>;
+    /**
+     * Fetch the decoded revert reason(s) for a transaction — error messages,
+     * revert strings, and recognized universal-subaccount errors extracted from
+     * a `debug_traceTransaction` call tree.
+     *
+     * Backed by the public (unauthenticated) `GET /revert_reason` endpoint; no
+     * API key required. The backend relies on the target chain's RPC supporting
+     * `debug_trace*`; on chains/RPCs without it the backend returns a 5xx whose
+     * detail explains why, surfaced here as an {@link AugustServerError}. Makes
+     * exactly one HTTP request and no RPC calls from the SDK itself.
+     *
+     * @param txHash Transaction hash to trace.
+     * @param chain Numeric August chain id the transaction is on (e.g. `1` for Ethereum mainnet).
+     * @returns The decoded {@link IRevertReason}; all arrays empty when the trace yielded no matching signal.
+     * @throws AugustValidationError When `txHash` is empty or `chain` is not an integer.
+     * @throws AugustServerError When the chain/RPC does not support tracing, or the API otherwise responds non-2xx.
+     * @example
+     *   const r = await sdk.apiModule.getRevertReason('0xabc…', 1);
+     *   console.log(r.revert_reasons);
+     */
+    getRevertReason(txHash: string, chain: number): Promise<IRevertReason>;
+    /**
+     * Retrieve every tracked OTC position.
+     *
+     * Backed by the admin-only `GET /otc/position` backend endpoint, so the
+     * configured August API key must belong to an admin user. Makes exactly one
+     * HTTP request and no RPC calls.
+     *
+     * @returns Array of {@link IOtcPositionRead}; empty when there are no OTC positions.
+     * @throws AugustAuthError When the API key is missing or not admin-scoped.
+     * @throws AugustServerError When the API responds with a non-2xx status.
+     * @example
+     *   const positions = await sdk.apiModule.getOtcPositions();
+     */
+    getOtcPositions(): Promise<IOtcPositionRead[]>;
+    /**
+     * Retrieve OTC margin requirements, optionally filtered by counterparty
+     * and/or payer.
+     *
+     * Backed by the admin-only `GET /otc/margin_requirement` backend endpoint,
+     * so the configured August API key must belong to an admin user. Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param options - Optional filters
+     * @param options.otcCounterpartyId - Restrict to a single counterparty (UUID)
+     * @param options.payer - Restrict to a single payer address
+     * @returns Array of {@link IOtcMarginRequirement} matching the filters (all when none given).
+     * @throws AugustAuthError When the API key is missing or not admin-scoped.
+     * @throws AugustServerError When the API responds with a non-2xx status.
+     * @example
+     *   const reqs = await sdk.apiModule.getOtcMarginRequirements({ payer: '0xabc…' });
+     */
+    getOtcMarginRequirements(options?: {
+        otcCounterpartyId?: string;
+        payer?: string;
+    }): Promise<IOtcMarginRequirement[]>;
+    /**
+     * List the subaccounts linked to a vault (curator surface).
+     *
+     * Backed by the curator-or-admin `GET
+     * /curator/vaults/{vault_address}/subaccounts` backend endpoint, so the
+     * configured August API key must belong to the vault's curator or an admin.
+     * Makes exactly one HTTP request and no RPC calls.
+     *
+     * @param vaultAddress - The vault address (EVM `0x…`, Solana, or Stellar)
+     * @returns Array of subaccount records linked to the vault (same shape as the subaccount directory); empty when none are linked.
+     * @throws AugustValidationError When `vaultAddress` is not a valid address.
+     * @throws AugustAuthError When the API key is missing or not curator/admin for the vault.
+     * @throws AugustServerError When the API responds with a non-2xx status.
+     * @example
+     *   const subs = await sdk.apiModule.getCuratorVaultSubaccounts('0xvault…');
+     */
+    getCuratorVaultSubaccounts(vaultAddress: string): Promise<IWSSubaccountListItem[]>;
+    /**
+     * Get on-chain whitelist status for every subaccount linked to a vault
+     * (curator surface).
+     *
+     * Backed by the curator-or-admin `GET
+     * /curator/vaults/{vault_address}/whitelist` backend endpoint. EVM vaults
+     * only — non-EVM vaults manage access internally and the backend returns a
+     * 400 (surfaced as {@link AugustServerError}). Makes exactly one HTTP
+     * request and no RPC calls from the SDK.
+     *
+     * @param vaultAddress - The EVM vault address (`0x…`)
+     * @returns Array of {@link ICuratorWhitelistStatus}, one per linked subaccount; empty when the vault has no subaccounts.
+     * @throws AugustValidationError When `vaultAddress` is not a valid address.
+     * @throws AugustAuthError When the API key is missing or not curator/admin for the vault.
+     * @throws AugustServerError When the vault is non-EVM (backend 400) or the API otherwise responds non-2xx.
+     * @example
+     *   const status = await sdk.apiModule.getCuratorVaultWhitelist('0xvault…');
+     *   console.log(status.filter((s) => !s.is_whitelisted));
+     */
+    getCuratorVaultWhitelist(vaultAddress: string): Promise<ICuratorWhitelistStatus[]>;
+    /**
+     * List timelock (governance) requests for a vault on a chain, optionally
+     * filtered by status.
+     *
+     * Backed by the `GET /timelock-requests` backend endpoint. Makes exactly one
+     * HTTP request and no RPC calls.
+     *
+     * @param params.vaultAddress The vault address the requests target.
+     * @param params.chainId Numeric August chain id (must be a positive integer).
+     * @param params.status Status filter: `"scheduled"` (backend default), `"executed"`, `"cancelled"`, or `"all"`. Omit to use the backend default.
+     * @returns Array of {@link ITimelockRequest}; empty when the vault has no matching requests.
+     * @throws AugustValidationError When `vaultAddress` is invalid or `chainId` is not a positive integer.
+     * @throws AugustServerError When the API responds with a non-2xx status (e.g. an invalid status filter).
+     * @example
+     *   const reqs = await sdk.apiModule.getTimelockRequests({ vaultAddress: '0xvault…', chainId: 1 });
+     */
+    getTimelockRequests(params: {
+        vaultAddress: string;
+        chainId: number;
+        status?: string;
+    }): Promise<ITimelockRequest[]>;
+    /**
+     * Compute a vault's performance fees over a period (backend-computed from
+     * its snapshot history).
+     *
+     * Backed by `GET /metrics/vault_performance_fees`. The backend runs pandas
+     * over the vault's full snapshot history, so the first call is slow; results
+     * are cached server-side for 20 minutes. Makes exactly one HTTP request and
+     * no RPC calls.
+     *
+     * @param params.vault The vault address (EVM `0x…`, Solana, or Stellar).
+     * @param params.annualizedFeesPct Annualized performance-fee percentage. Defaults to 20.
+     * @param params.nativeDenominated Whether to denominate in the vault's native token. Defaults to `true`.
+     * @param params.calculationPeriod Period preset — `"YearToDate"` (default) or `"MonthToDate"`. Ignored by the backend when a custom `startDate`/`endDate` range is supplied.
+     * @param params.startDate ISO-8601 datetime range start. Must be supplied together with `endDate`.
+     * @param params.endDate ISO-8601 datetime range end. Must be supplied together with `startDate`.
+     * @returns The vault's {@link IVaultPerformanceFees} computation.
+     * @throws AugustValidationError When `vault` is invalid, or exactly one of `startDate`/`endDate` is supplied.
+     * @throws AugustServerError When there is insufficient snapshot data for the period, or the API otherwise responds non-2xx.
+     * @example
+     *   const fees = await sdk.apiModule.getVaultPerformanceFees({ vault: '0xvault…' });
+     *   console.log(fees.total_perf_fees_asset);
+     */
+    getVaultPerformanceFees(params: {
+        vault: string;
+        annualizedFeesPct?: number;
+        nativeDenominated?: boolean;
+        calculationPeriod?: string;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<IVaultPerformanceFees>;
+    /**
+     * Fetch a vault's NAV-oracle classification table — how each position/token
+     * is priced (Primary / Secondary Market / CeFi) and its USD value, plus
+     * warnings for tokens that could not be resolved.
+     *
+     * Backed by the public (unauthenticated) `GET
+     * /upshift/oracle_classification/{vault_address}` endpoint; no API key
+     * required. Reads the newest daily snapshot. Makes exactly one HTTP request
+     * and no RPC calls from the SDK.
+     *
+     * @param vault The vault address (EVM `0x…`, Solana, or Stellar).
+     * @param chainId Numeric August chain id the vault lives on.
+     * @returns The vault's {@link IOracleClassification}.
+     * @throws AugustValidationError When `vault` is invalid or `chainId` is not an integer.
+     * @throws AugustServerError When the vault or its snapshot is not found, or the API otherwise responds non-2xx.
+     * @example
+     *   const cls = await sdk.apiModule.getVaultOracleClassification('0xvault…', 1);
+     *   console.log(cls.warnings);
+     */
+    getVaultOracleClassification(vault: string, chainId: number): Promise<IOracleClassification>;
     /**
      * Fetch the historical unrealized-PnL series for a vault, newest first,
      * as computed by the August backend from periodic vault snapshots.
@@ -15175,7 +15435,7 @@ export declare class AugustBase {
      * @throws If `appName` is missing, malformed, or out of the allowed
      *   length range — see {@link IAugustBase.appName}.
      */
-    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, }: IAugustBase);
+    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, }: IAugustBase);
     /**
      * Verify API keys and authorize SDK usage.
      * TODO: initialize class with appropriate keys and verify august key
@@ -15743,6 +16003,31 @@ export declare class AugustServerError extends AugustSDKError {
 export declare class AugustSubAccounts extends AugustBase {
     private headers;
     constructor(baseConfig: IAugustBase);
+    /**
+     * Retrieves one page of the directory of all August subaccounts.
+     *
+     * Backed by the admin-only `GET /subaccount` backend endpoint, so the
+     * August API key configured on the SDK must belong to an admin user —
+     * non-admin keys are rejected with an auth error by the backend. Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param options - Pagination window over the subaccount directory
+     * @param options.offset - Number of records to skip. Defaults to 0; must be a non-negative integer.
+     * @param options.limit - Page size. Defaults to 100; must be an integer between 1 and 1000 (backend maximum).
+     * @returns The page of subaccount records (address, internal/friendly names, status, type, linked chains, risk metadata). An empty array means the offset is past the end of the directory.
+     * @throws AugustValidationError when `offset` or `limit` is out of range
+     * @throws AugustAuthError when the API key is missing or not admin-scoped
+     * @example
+     *   const page = await augustSdk.subAccountsModule.getAllSubaccounts({
+     *     offset: 0,
+     *     limit: 200,
+     *   });
+     *   console.log(page.map((s) => `${s.internal_name}: ${s.address}`));
+     */
+    getAllSubaccounts(options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<IWSSubaccountListItem[]>;
     /**
      * Retrieves the health factor for a subaccount.
      * @param subaccountAddress - The address of the subaccount to query
@@ -15882,6 +16167,73 @@ export declare class AugustSubAccounts extends AugustBase {
         netAccountValue: number;
         totalEquityValue: number;
     }>;
+    /**
+     * Retrieves a subaccount's on-chain transaction history, newest first,
+     * optionally windowed by a time range.
+     *
+     * Backed by the authenticated `GET /transactions/v2` backend endpoint,
+     * which resolves and authorizes the subaccount, so the configured August
+     * API key must be authorized for it (an admin-scoped key always is). Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @param options - Optional time window
+     * @param options.startTime - ISO-8601 datetime lower bound (inclusive); omit for no lower bound
+     * @param options.endTime - ISO-8601 datetime upper bound (inclusive); omit for no upper bound
+     * @returns The subaccount's transactions with decoded logs, transfers, and function names
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustAuthError When the API key is missing or not authorized for the subaccount
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const txs = await augustSdk.subAccountsModule.getSubaccountTransactions(
+     *     '0xabc…',
+     *     { startTime: '2026-01-01T00:00:00Z' },
+     *   );
+     */
+    getSubaccountTransactions(subaccountAddress: IAddress, options?: {
+        startTime?: string;
+        endTime?: string;
+    }): Promise<ISubaccountTransaction[]>;
+    /**
+     * Retrieves the full loan-book detail for a single loan by its address and
+     * chain.
+     *
+     * Backed by the admin-only `GET /subaccount/loans/{loan_address}` backend
+     * endpoint (60-second server-side cache), so the configured August API key
+     * must belong to an admin user. Makes exactly one HTTP request and no RPC
+     * calls.
+     *
+     * @param loanAddress - The loan contract address
+     * @param chainId - Numeric August chain id the loan lives on (e.g. `1` for Ethereum mainnet)
+     * @returns The loan's {@link ILoanBookInfo} detail
+     * @throws AugustValidationError When `chainId` is not an integer
+     * @throws AugustAuthError When the API key is missing or not admin-scoped
+     * @throws AugustServerError When the loan or chain is not found, or the API otherwise responds non-2xx
+     * @example
+     *   const loan = await augustSdk.subAccountsModule.getSubaccountLoanByAddress(
+     *     '0xloan…',
+     *     1,
+     *   );
+     */
+    getSubaccountLoanByAddress(loanAddress: string, chainId: number): Promise<ILoanBookInfo>;
+    /**
+     * Retrieves cross-chain DeBank protocol positions and token balances for a
+     * subaccount and its associated strategies.
+     *
+     * Backed by `GET /subaccount/{subaccount_address}/debank` (300-second
+     * server-side cache). This is a slow endpoint — it fans out to DeBank
+     * across every supported chain — so expect higher latency than other
+     * subaccount reads. Makes exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The subaccount's DeBank positions/tokens plus per-strategy breakdowns
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const debank = await augustSdk.subAccountsModule.getSubaccountDebank('0xabc…');
+     *   console.log(debank.subaccount.positions.length);
+     */
+    getSubaccountDebank(subaccountAddress: IAddress): Promise<ISubaccountDebank>;
 }
 
 /** Request exceeded its deadline. */
@@ -16818,6 +17170,24 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
       address?: string;
   }): void;
 
+  /**
+   * Decimal precision of the native gas token on every EVM chain this SDK
+   * supports (ETH, Base, Arbitrum, Avalanche, Polygon, BNB, HyperEVM, Unichain,
+   * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo).
+   *
+   * All of them use 18-decimal native tokens, so this is a single constant rather
+   * than a per-chain map. It exists because the native token has no ERC-20
+   * `decimals()` to read on-chain: when a subgraph row denominates an amount in
+   * the native token it is flagged with a sentinel address ({@link NATIVE_ADDRESS}
+   * or the zero address) instead of a real contract, and callers must substitute
+   * this value rather than attempting (and failing) a `decimals()` read.
+   *
+   * Non-EVM natives differ (SOL is 9, XLM is 7) and are handled by their own
+   * adapters — those chains never flow through the EVM `decimals()` path this
+   * constant serves.
+   */
+  export declare const EVM_NATIVE_DECIMALS = 18;
+
   /**
    * EVM Adapter for August SDK
    * Supports both ethers Signer/Wallet and wagmi/viem WalletClient
@@ -17185,6 +17555,14 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
       readonly localnet: "http://127.0.0.1:8899";
   };
 
+  /**
+   * Fetch one page of the subaccount directory (admin-only backend endpoint)
+   */
+  export declare const fetchAllSubaccounts: (pagination: {
+      offset?: number;
+      limit?: number;
+  }, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubaccountListItem[]>;
+
   /**
    * Make unauthenticated requests to August public API endpoints.
    * Used for fetching vault metadata and public market data.
@@ -17251,11 +17629,24 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
    */
   export declare const fetchSubaccountCefiPositions: (address: IAddress, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubaccountCefi[]>;
 
+  /**
+   * Fetch cross-chain DeBank positions for a subaccount (`GET
+   * /subaccount/{subaccount_address}/debank`). Slow endpoint (300-second
+   * server-side cache) — it fans out across every supported chain.
+   */
+  export declare const fetchSubaccountDebank: (address: IAddress, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ISubaccountDebank>;
+
   /**
    * Fetch subaccount health factor for a given subaccount address
    */
   export declare const fetchSubaccountHeathFactor: (address: IAddress, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubAccountHealthFactor>;
 
+  /**
+   * Fetch a single loan's loan-book detail by loan address + chain
+   * (admin-only `GET /subaccount/loans/{loan_address}`).
+   */
+  export declare const fetchSubaccountLoanByAddress: (loanAddress: string, chainId: number, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ILoanBookInfo>;
+
   /**
    * Fetch subaccount loans details
    */
@@ -17275,6 +17666,16 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
    */
   export declare const fetchSubaccountSummary: (address: IAddress, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubaccountSummary>;
 
+  /**
+   * Fetch a subaccount's transaction history (authenticated `GET
+   * /transactions/v2`), optionally windowed by ISO-8601 start/end datetimes.
+   */
+  export declare const fetchSubaccountTransactions: (payload: {
+      address: IAddress;
+      startTime?: string;
+      endTime?: string;
+  }, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ISubaccountTransaction[]>;
+
   /**
    * Fetch a swap quote and the calldata required for the on-chain SwapRouter
    * to execute it.
@@ -17654,6 +18055,12 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                options: IVaultBaseOptions;
            }): Promise<INormalizedNumber>;
 
+           /**
+            * Read the active base for the `public` server — the SDK-level override if set,
+            * otherwise the compiled-in `WEBSERVER_URL.public`.
+            */
+           export declare function getPublicApiBaseUrl(): string;
+
            /**
             * Fetch receipt token address from tokenized vault contract.
             * Results are cached to minimize RPC calls.
@@ -18418,6 +18825,25 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 * with different timeouts in the same process.
                 */
                timeoutMs?: number;
+               /**
+                * Override the base URL for the SDK's unauthenticated `public` vault-catalog
+                * API (what `getVault` / `getVaults` / `fetchTokenizedVault` read from).
+                * Defaults to the compiled-in prod base
+                * (`https://api.augustdigital.io/api/v1`) when omitted — so production apps
+                * pass nothing and behaviour is unchanged.
+                *
+                * Set this ONLY for a non-prod deployment that runs against an isolated
+                * backend (e.g. a staging API serving staging-only vaults). Must be an
+                * absolute http(s) URL including any base path, e.g.
+                * `https://api.staging.augustdigital.io/api/v1`. Invalid values are ignored.
+                *
+                * Note: this is a process-global override on the underlying fetcher helpers,
+                * applied on EVERY construction — so the last `AugustSDK` instantiated is
+                * authoritative, and one that omits `publicApiBaseUrl` RESETS to the prod
+                * default. (Stricter than `timeoutMs`, which stays sticky when omitted, since
+                * a stale cross-environment base is higher blast-radius than a stale timeout.)
+                */
+               publicApiBaseUrl?: string;
            }
 
            /** Options for {@link balanceOf}. */
@@ -18436,6 +18862,68 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                explorer: string;
            };
 
+           /**
+            * Per-collateral-token breakdown within a collateral simulation (backend
+            * `CollateralDetailsResult` schema). `chain` is the numeric August chain id.
+            */
+           export declare interface ICollateralDetailsResult {
+               chain: number;
+               token_address: IAddress;
+               price: number;
+               allocation: number;
+               collateral_value_from_redeployed_loan_usd: number;
+               collateral_value_usd: number;
+               amount_usd: number;
+               amount_token: number;
+               effective_discount_factor: number;
+               is_top_up: boolean;
+           }
+
+           /**
+            * Result of `GET /risk/collateral_excess_or_deficit` (backend
+            * `CollateralExcessOrDeficit` schema). A positive value is excess collateral
+            * that could be withdrawn; a negative value is the shortfall that must be
+            * deposited to reach the target health factor.
+            */
+           export declare interface ICollateralExcessOrDeficit {
+               amount_usd: number;
+               amount_token: number;
+           }
+
+           /**
+            * Request body for `POST /risk/collateral_simulation` (backend
+            * `CollateralSimulation` schema). Chain fields are numeric August chain ids.
+            * `collateral_tokens` is a list of `[chain, address]` pairs and
+            * `collateral_token_allocation` the matching per-token weights (normalized
+            * server-side, so relative magnitudes are what matter). When `on_platform`
+            * is `true`, both `loan_redeployed_token_*` fields are required by the
+            * backend.
+            */
+           export declare interface ICollateralSimulationInput {
+               loan_token_chain: number;
+               loan_token_address: IAddress;
+               loan_amount: number;
+               on_platform?: boolean;
+               loan_redeployed_token_chain?: number | null;
+               loan_redeployed_token_address?: IAddress | null;
+               collateral_tokens: [number, IAddress][];
+               collateral_token_allocation: number[];
+               target_health_factor?: number;
+           }
+
+           /**
+            * Result of `POST /risk/collateral_simulation` (backend
+            * `CollateralSimulationResults` schema). `collateral_details` is keyed by
+            * `"<symbol>_<chainName>"`.
+            */
+           export declare interface ICollateralSimulationResults {
+               total_debt_usd: number;
+               total_required_collateral_usd: number;
+               total_collateral_value_from_redeployed_loan_usd: number;
+               health_factor: number;
+               collateral_details: Record<string, ICollateralDetailsResult>;
+           }
+
            export declare interface IComposabilityIntegration {
                name: string;
                description: string;
@@ -18730,6 +19218,16 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                hubOnlyReceipt?: boolean;
            }
 
+           /**
+            * On-chain whitelist status of one subaccount linked to a vault, from
+            * `GET /curator/vaults/{vault_address}/whitelist` (backend
+            * `WhitelistStatusResponse` schema). EVM vaults only.
+            */
+           export declare interface ICuratorWhitelistStatus {
+               address: IAddress;
+               is_whitelisted: boolean;
+           }
+
            export declare interface IDebankAccountData {
                positions: IDebankUserProtocol[];
                app_positions: IDebankAppProtocol[];
@@ -18883,6 +19381,20 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                portfolio_item_list: IDebankPortfolioItemObject[];
            }
 
+           /**
+            * A token's discount-factor ladder from `GET /risk/discount_factors`
+            * (backend `DiscountFactorRead` schema). `steps` are ascending notional
+            * thresholds (in the token's smallest unit) and `factors` the corresponding
+            * ascending haircut multipliers in `[0, 1]`; the two arrays are equal length.
+            * `chain` is the numeric August chain id.
+            */
+           export declare interface IDiscountFactorLadder {
+               steps: number[] | null;
+               factors: number[] | null;
+               address: IAddress;
+               chain: number;
+           }
+
            export declare const IDLE_CAPITAL_BORROWER_ADDRESS: `0x${string}`[];
 
            declare interface IEmberVault {
@@ -19067,8 +19579,43 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                timestamp_: string;
            }
 
+           /**
+            * One loan-book entry from the admin loan-book endpoints (backend
+            * `LoanBookInfo` schema). Amounts are decimal-adjusted floats; monetary
+            * fields are denominated in the loan's principal token. `deployed_date` is an
+            * ISO-8601 datetime string; `state` is the backend `LoanStateStr` value
+            * (e.g. `"ACTIVE"`).
+            */
+           export declare interface ILoanBookInfo {
+               address: IAddress;
+               lender: IAddress;
+               borrower: IAddress;
+               state: string;
+               total_repaid: number;
+               principal_token: IWhitelistedToken;
+               principal_amount: number;
+               interest_amount: number;
+               upcoming_payment: ILoanUpcomingPayment;
+               apr: number;
+               initial_principal_amount: number;
+               deployed_date: string;
+               payment_interval: number;
+               total_interest_payment_fees: number;
+               lender_apr: number;
+           }
+
            declare type ILoanOracleFeeCategories = 'LOAN.REPAY.INTERESTS';
 
+           /**
+            * The amount and due date of a loan's next scheduled payment, as serialized
+            * by the backend `UpcomingPayment` schema. `due_date` is an ISO-8601 datetime
+            * string.
+            */
+           export declare interface ILoanUpcomingPayment {
+               amount: number;
+               due_date: string;
+           }
+
            /**
             * Structured logger interface (debug/info/warn/error). Sanitization runs
             * before any method here is invoked, so implementations needn't scrub secrets.
@@ -19174,6 +19721,45 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare type IOperatorTypeEnum = 'eoa' | 'subaccount';
 
+           /**
+            * A vault's NAV-oracle classification from the public
+            * `GET /upshift/oracle_classification/{vault_address}` endpoint (backend
+            * `OracleClassificationResponse` schema). `warnings` lists tokens that could
+            * not be resolved (`"unresolved:<symbol>"`). `snapshot_at` is an ISO-8601
+            * datetime string.
+            */
+           export declare interface IOracleClassification {
+               vault_address: IAddress;
+               chain_id: number;
+               snapshot_at: string;
+               methodology: string;
+               rows: IOracleClassificationRow[];
+               warnings: string[];
+           }
+
+           /**
+            * One row of a vault's NAV-oracle classification table (backend
+            * `OracleClassificationRow` schema) — how a single position/token is priced
+            * and its USD value.
+            */
+           export declare interface IOracleClassificationRow {
+               position: string;
+               type: string;
+               oracle_source: string;
+               usd_value: number;
+           }
+
+           /**
+            * An OTC margin requirement from `GET /otc/margin_requirement` (backend
+            * `IOTCMarginRequirementRead` schema) — the margin the `payer` must post to
+            * the given counterparty.
+            */
+           export declare interface IOtcMarginRequirement {
+               otc_counter_party_id: string;
+               margin_requirement: number;
+               payer: IAddress;
+           }
+
            export declare interface IOTCPosition {
                value: number;
                underlying: string;
@@ -19184,6 +19770,20 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                trades: IOTCTrade[];
            }
 
+           /**
+            * A tracked position from `GET /otc/position` (backend `IPositionRead`
+            * schema). `configs` is a free-form JSON object of position-specific
+            * settings; `category` is the position category (e.g. `"otc"`).
+            */
+           export declare interface IOtcPositionRead {
+               id: string;
+               slug: string;
+               position_class: string | null;
+               configs: Record<string, unknown> | null;
+               category: string | null;
+               position_discount_factor: number | null;
+           }
+
            export declare interface IOTCTrade {
                value: number;
                payer: string;
@@ -19465,6 +20065,18 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                refundChainId?: number;
            }
 
+           /**
+            * Result of the public `GET /revert_reason` endpoint (backend `RevertResponse`
+            * schema) — the decoded failure reasons for a reverted transaction, collected
+            * from a `debug_traceTransaction` call tree. All three arrays are empty when
+            * no matching signal was found in the trace.
+            */
+           export declare interface IRevertReason {
+               error_messages: string[];
+               revert_reasons: string[];
+               universal_subaccount_errors: string[];
+           }
+
            export declare type IRwaRedeemOptions = {
                /** RwaRedeemSubaccount contract address */
                target: IAddress;
@@ -19760,6 +20372,54 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                utila_wallet_id?: string;
            }
 
+           /**
+            * Cross-chain DeBank protocol positions for a subaccount and its associated
+            * strategies (backend `SubaccountDebankAccountData` schema). `strategies` is
+            * keyed by strategy address. This endpoint is slow (300-second server-side
+            * cache) as it fans out across every supported chain.
+            */
+           export declare interface ISubaccountDebank {
+               subaccount: ISubaccountDebankData;
+               strategies: Record<string, ISubaccountDebankData>;
+           }
+
+           /**
+            * DeBank positions and tokens for a single account (backend
+            * `DebankAccountData` schema). `positions`, `app_positions`, and `tokens`
+            * are passed through as raw DeBank objects.
+            */
+           export declare interface ISubaccountDebankData {
+               positions: unknown[];
+               app_positions: unknown[];
+               tokens: unknown[];
+           }
+
+           /**
+            * One transaction record from `GET /transactions/v2` (backend
+            * `TransactionAPIRead` schema). `chain` is the numeric August chain id;
+            * `value` is decimal-adjusted; `timestamp` is a Unix epoch (seconds).
+            * `from_` mirrors the backend field name (`from` is reserved). Nested
+            * `logs` / `transfers` / `function_signature` / `otc_cashflow` are passed
+            * through as-is. `transaction_name` is the resolved function name (or the raw
+            * selector when unknown).
+            */
+           export declare interface ISubaccountTransaction {
+               id: string;
+               tx_hash: string;
+               chain: number;
+               from_: IAddress;
+               to: IAddress;
+               value: number;
+               block_number: number;
+               timestamp: number;
+               selector: string | null;
+               logs: unknown[];
+               transfers: unknown[];
+               function_signature: Record<string, unknown> | null;
+               otc_cashflow: Record<string, unknown> | null;
+               transaction_name: string | null;
+           }
+
            export declare interface ISubgraphBase {
                id: string;
                contractId_: IAddress;
@@ -19775,6 +20435,14 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                owner: IAddress;
                senderAddr?: IAddress;
                amountIn?: string;
+               /**
+                * Deposit asset token address (evm-2 / pre-deposit vaults). The deposited
+                * asset can differ from the vault's underlying and carry different decimals
+                * (e.g. RLUSD at 18 into a 6-decimal sentUSD vault), so `amountIn` must be
+                * normalized against this token's decimals, not the vault's. Absent for
+                * single-asset vaults.
+                */
+               assetIn?: IAddress;
            }
 
            export declare interface ISubgraphFormattedLoan {
@@ -20093,6 +20761,31 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                wallet: IAddress;
            }): Promise<boolean | undefined>;
 
+           /**
+            * One timelock request from `GET /timelock-requests` (backend
+            * `ITimelockRequestRead` schema). `chain_id` is the numeric chain id;
+            * `status` is one of `"scheduled" | "executed" | "cancelled"`; `params` is a
+            * free-form JSON object; datetime fields are ISO-8601 strings.
+            */
+           export declare interface ITimelockRequest {
+               id: string;
+               hash: string;
+               vault_address: IAddress;
+               timelock_address: IAddress;
+               chain_id: number;
+               action_id: string;
+               params: Record<string, unknown>;
+               status: string;
+               schedule_tx_hash: string;
+               execute_tx_hash: string | null;
+               cancel_tx_hash: string | null;
+               submitted_by: string | null;
+               scheduled_at: string;
+               resolved_at: string | null;
+               created_at: string | null;
+               updated_at: string | null;
+           }
+
            export declare interface ITokenizedVault {
                address: string;
                yield_distributor: string;
@@ -20639,6 +21332,28 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                }>;
            }
 
+           /**
+            * Performance-fee computation for a vault from
+            * `GET /metrics/vault_performance_fees` (backend `UpshiftVaultPerformanceFees`
+            * schema). High/low water marks are share-price levels; `*_datetime` fields
+            * are ISO-8601 strings. `calculation_period` is `"YearToDate"` /
+            * `"MonthToDate"` (null when a custom date range was supplied).
+            */
+           export declare interface IVaultPerformanceFees {
+               previous_water_mark: number;
+               previous_water_mark_datetime: string;
+               last_water_mark: number;
+               last_water_mark_datetime: string;
+               is_in_drawdown: boolean;
+               asset_symbol: string | null;
+               total_pnl_in_asset: number;
+               total_perf_fees_asset: number;
+               calculation_period: string | null;
+               annualized_fees_pct: number;
+               underlying_asset_vs_native_perf: number | null;
+               native_token_symbol: string | null;
+           }
+
            export declare interface IVaultPnl {
                totalPnl: INormalizedNumber;
                pnlUsd: number;
@@ -20774,6 +21489,23 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                enabled?: boolean;
            }
 
+           /**
+            * A whitelisted token as embedded in loan-book records by the backend
+            * `WhitelistedTokenModel` schema. `chain` is the numeric August chain id
+            * (backend `Chain` IntEnum value, e.g. `1` for Ethereum mainnet).
+            */
+           export declare interface IWhitelistedToken {
+               chain: number;
+               name: string;
+               token_type: string;
+               address: IAddress;
+               decimals: number;
+               symbol: string;
+               discount_factor: number;
+               img_url: string | null;
+               price: number | null;
+           }
+
            /**
             * Statuses
             */
@@ -21015,6 +21747,44 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                total_loan_value: number;
            }
 
+           /**
+            * Chain record attached to a subaccount directory entry, as serialized by the
+            * backend `IChainRead` schema.
+            */
+           export declare interface IWSSubaccountListChain {
+               id: string;
+               chain_id: number;
+               name: string;
+           }
+
+           /**
+            * One subaccount record from the admin-only `GET /subaccount` directory
+            * endpoint (backend `ISubaccountRead` schema). Nullable fields are optional
+            * metadata the operations team may not have filled in.
+            */
+           export declare interface IWSSubaccountListItem {
+               id: string;
+               user_id: string | null;
+               internal_name: string;
+               friendly_name: string | null;
+               address: IAddress;
+               status: string | null;
+               subaccount_type: string | null;
+               min_health_factor: number | null;
+               estimated_apr: number | null;
+               notes: string | null;
+               proxy_salt: string | null;
+               admin_salt: string | null;
+               disable_discount_factor: boolean | null;
+               turnkey_address: IAddress | null;
+               autopay_frequency: string | null;
+               implementation: string | null;
+               variant: string | null;
+               default_fee_rate_in_bips: number | null;
+               wallet_role: string | null;
+               chains: IWSSubaccountListChain[];
+           }
+
            export declare interface IWSSubaccountLoan {
                address: IAddress;
                lender: IAddress;
@@ -22588,6 +23358,37 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
             declare function setLogger(customLogger: SDKLogger): void;
 
+            /**
+             * Override the base URL used for `WEBSERVER_URL.public` requests — the
+             * unauthenticated vault-catalog API that `getVault` / `fetchTokenizedVault`
+             * (and the other `fetchAugustPublic` callers) read from. Defaults to the
+             * compiled-in prod base (`https://api.augustdigital.io/api/v1`); pass `null`
+             * (or call with no arguments) to clear.
+             *
+             * Intended for non-prod deployments that run against an ISOLATED backend
+             * (e.g. a staging API): set it once at construction via
+             * `IAugustBase.publicApiBaseUrl` so a staging-only vault resolves. Production
+             * leaves it unset, so behaviour is unchanged.
+             *
+             * This is a process-global override on the fetcher helpers. The SDK constructor
+             * calls it on EVERY instantiation (with `null` when `publicApiBaseUrl` is
+             * omitted), so the last `AugustSDK` instantiated is authoritative — a prod
+             * instance resets it to the default even after a prior staging instance set it.
+             * An invalid or non-http(s) URL is treated as "no override": it RESETS to the
+             * compiled-in default (warned) rather than retaining a prior value, so a bad env
+             * value can neither break fetches nor silently leave a previous instance's base
+             * in place.
+             *
+             * Whenever the effective base CHANGES, the shared public-response cache is
+             * cleared, so catalog data fetched from the previous backend is never served for
+             * the new one (e.g. a prod-cached vault leaking into a staging instance). Base
+             * changes happen at construction, when the cache is cold, so this is ~free.
+             *
+             * @param url - Absolute http(s) base URL (trailing slash is trimmed). `null`, or
+             *   an invalid / non-http(s) value, resets to the compiled-in public base.
+             */
+            export declare function setPublicApiBaseUrl(url?: string | null): void;
+
             export declare const setSafeCache: <T>(key: string, value: T) => Promise<void>;
 
             /**
@@ -23457,6 +24258,11 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                                     subaccount: IAddress;
                                     useDebank: boolean;
                                 };
+                                MonarqXRP: {
+                                    address: IAddress;
+                                    subaccount: IAddress;
+                                    useDebank: boolean;
+                                };
                             };
 
                             /**
@@ -24028,6 +24834,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                                     refresh: string;
                                 };
                                 subaccount: {
+                                    list: (offset?: number, limit?: number) => string;
                                     rewards: (subaccount: IAddress) => string;
                                     tokens: (subaccount: IAddress) => string;
                                     twap: {
@@ -24042,14 +24849,43 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                                     loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
                                     cefi: (subaccount: IAddress) => string;
                                     otc_positions: (subaccount: IAddress) => string;
+                                    loanByAddress: (loanAddress: string, chainId: number) => string;
                                     _: (subaccount: IAddress) => string;
                                 };
+                                transactions: {
+                                    v2: (subaccount: string, startTime?: string, endTime?: string) => string;
+                                };
+                                otc: {
+                                    positions: string;
+                                    marginRequirements: (otcCounterpartyId?: string, payer?: string) => string;
+                                };
+                                curator: {
+                                    vaultSubaccounts: (vaultAddress: string) => string;
+                                    vaultWhitelist: (vaultAddress: string) => string;
+                                };
+                                timelockRequests: (vaultAddress: string, chainId: number, status?: string) => string;
                                 users: {
                                     get: string;
                                 };
+                                dashboard: {
+                                    loans: string;
+                                };
+                                risk: {
+                                    discountFactors: string;
+                                    collateralExcessOrDeficit: (subaccount: string, tokenAddress: string, tokenChain: number, targetHealthFactor?: number) => string;
+                                    collateralSimulation: string;
+                                };
                                 prices: (symbol: string) => string;
                                 metrics: {
                                     pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
+                                    vaultPerformanceFees: (params: {
+                                        vaultAddress: string;
+                                        annualizedFeesPct: number;
+                                        nativeDenominated: boolean;
+                                        calculationPeriod: string;
+                                        startDate?: string;
+                                        endDate?: string;
+                                    }) => string;
                                 };
                                 public: {
                                     integrations: {
@@ -24083,6 +24919,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                                         unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
                                         unrealizedLatest: string;
                                     };
+                                    revertReason: (txHash: string, chain: number) => string;
+                                    oracleClassification: (vaultAddress: string, chainId: number) => string;
                                 };
                                 upshift: {
                                     vaults: {