@augustdigital/sdk 8.7.2 → 8.9.0

package/lib/core/analytics/method-taxonomy.js

@@ -24,6 +24,18 @@ exports.METHOD_CATEGORIES = {
     getVaultPnl: 'read.vault',
     getVaultUnrealizedPnlHistory: 'read.vault',
     getLatestUnrealizedPnl: 'read.vault',
+    getDashboardLoans: 'read.vault',
+    getDiscountFactors: 'read.vault',
+    getCollateralExcessOrDeficit: 'read.vault',
+    simulateCollateral: 'read.vault',
+    getRevertReason: 'read.vault',
+    getOtcPositions: 'read.vault',
+    getOtcMarginRequirements: 'read.vault',
+    getCuratorVaultSubaccounts: 'read.vault',
+    getCuratorVaultWhitelist: 'read.vault',
+    getTimelockRequests: 'read.vault',
+    getVaultPerformanceFees: 'read.vault',
+    getVaultOracleClassification: 'read.vault',
     getVaultBorrowerHealthFactor: 'read.vault',
     getYieldLastRealizedOn: 'read.vault',
     getVaultActivity: 'read.vault',
@@ -42,11 +54,15 @@ exports.METHOD_CATEGORIES = {
     getPrice: 'read.price',
     getUserPoints: 'read.points',
     fetchPointsLeaderboard: 'read.points',
+    getAllSubaccounts: 'read.subaccount',
     getSubaccountHealthFactor: 'read.subaccount',
     getSubaccountLoans: 'read.subaccount',
     getSubaccountCefiPositions: 'read.subaccount',
     getSubaccountOtcPositions: 'read.subaccount',
     getSubaccountSummary: 'read.subaccount',
+    getSubaccountTransactions: 'read.subaccount',
+    getSubaccountLoanByAddress: 'read.subaccount',
+    getSubaccountDebank: 'read.subaccount',
     getStakingPositions: 'read.staking',
     getVaultStakingPositions: 'read.staking',
     getLayerZeroDeposits: 'read.layerzero',

package/lib/core/analytics/version.d.ts

@@ -3,4 +3,4 @@
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-export declare const SDK_VERSION = "8.7.2";
+export declare const SDK_VERSION = "8.9.0";

package/lib/core/analytics/version.js

@@ -6,5 +6,5 @@ exports.SDK_VERSION = void 0;
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-exports.SDK_VERSION = '8.7.2';
+exports.SDK_VERSION = '8.9.0';
 //# sourceMappingURL=version.js.map

package/lib/core/base.class.d.ts

@@ -63,6 +63,25 @@ export interface IAugustBase {
      * 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;
 }
 interface IActiveNetwork {
     chainId: IChainId;
@@ -87,7 +106,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

package/lib/core/base.class.js

@@ -55,7 +55,7 @@ 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, }) {
+    constructor({ appName, providers = {}, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, }) {
         // Validate first so the failure mode is a clear, actionable error before
         // any provider / analytics side effects run.
         this.appName = validateAppName(appName);
@@ -88,6 +88,13 @@ class AugustBase {
         if (typeof timeoutMs === 'number') {
             (0, fetcher_1.setSdkRequestTimeout)(timeoutMs);
         }
+        // Repoint the unauthenticated `public` vault-catalog API when a non-prod
+        // deployment supplies an isolated backend. Called UNCONDITIONALLY so each
+        // instance is authoritative: an instance that omits `publicApiBaseUrl`
+        // passes `null` and RESETS to the compiled-in prod default. Without this a
+        // prior staging instance would leak into a later prod instance in the same
+        // process — the inverse of the isolation this option exists to provide.
+        (0, fetcher_1.setPublicApiBaseUrl)(publicApiBaseUrl ?? null);
     }
     /**
      * Verify API keys and authorize SDK usage.

package/lib/core/constants/core.d.ts

@@ -30,6 +30,7 @@ export declare const WEBSERVER_ENDPOINTS: {
         refresh: string;
     };
     subaccount: {
+        list: (offset?: number, limit?: number) => string;
         rewards: (subaccount: IAddress) => string;
         tokens: (subaccount: IAddress) => string;
         twap: {
@@ -44,14 +45,43 @@ export declare const WEBSERVER_ENDPOINTS: {
         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: {
@@ -85,6 +115,8 @@ export declare const WEBSERVER_ENDPOINTS: {
             unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
             unrealizedLatest: string;
         };
+        revertReason: (txHash: string, chain: number) => string;
+        oracleClassification: (vaultAddress: string, chainId: number) => string;
     };
     upshift: {
         vaults: {

package/lib/core/constants/core.js

@@ -33,6 +33,7 @@ exports.WEBSERVER_ENDPOINTS = {
         refresh: '/auth/refresh',
     },
     subaccount: {
+        list: (offset = 0, limit = 100) => `/subaccount?offset=${offset}&limit=${limit}`,
         rewards: (subaccount) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}/rewards`,
         tokens: (subaccount) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}/tokens`,
         twap: {
@@ -47,14 +48,80 @@ exports.WEBSERVER_ENDPOINTS = {
         loans: (subaccount, side = 'BOTH', active = true) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}/loans?side=${side}&active=${active}`,
         cefi: (subaccount) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}/cefi_position`,
         otc_positions: (subaccount) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}/otc_positions`,
+        loanByAddress: (loanAddress, chainId) => `/subaccount/loans/${encodeURIComponent(loanAddress)}?chain_id=${chainId}`,
         _: (subaccount) => `/subaccount/${(0, ethers_1.getAddress)(subaccount)}`,
     },
+    transactions: {
+        v2: (subaccount, startTime, endTime) => {
+            const params = new URLSearchParams({ address: subaccount });
+            if (startTime !== undefined)
+                params.set('start_time', startTime);
+            if (endTime !== undefined)
+                params.set('end_time', endTime);
+            return `/transactions/v2?${params.toString()}`;
+        },
+    },
+    otc: {
+        positions: '/otc/position',
+        marginRequirements: (otcCounterpartyId, payer) => {
+            const params = new URLSearchParams();
+            if (otcCounterpartyId !== undefined)
+                params.set('otc_counter_party_id', otcCounterpartyId);
+            if (payer !== undefined)
+                params.set('payer', payer);
+            const query = params.toString();
+            return `/otc/margin_requirement${query ? `?${query}` : ''}`;
+        },
+    },
+    curator: {
+        vaultSubaccounts: (vaultAddress) => `/curator/vaults/${encodeURIComponent(vaultAddress)}/subaccounts`,
+        vaultWhitelist: (vaultAddress) => `/curator/vaults/${encodeURIComponent(vaultAddress)}/whitelist`,
+    },
+    timelockRequests: (vaultAddress, chainId, status) => {
+        const params = new URLSearchParams({
+            vaultAddress,
+            chainId: String(chainId),
+        });
+        if (status !== undefined)
+            params.set('status', status);
+        return `/timelock-requests?${params.toString()}`;
+    },
     users: {
         get: '/users',
     },
+    dashboard: {
+        loans: '/dashboard/loans',
+    },
+    risk: {
+        discountFactors: '/risk/discount_factors',
+        collateralExcessOrDeficit: (subaccount, tokenAddress, tokenChain, targetHealthFactor) => {
+            const params = new URLSearchParams({
+                address: subaccount,
+                token_address: tokenAddress,
+                token_chain: String(tokenChain),
+            });
+            if (targetHealthFactor !== undefined)
+                params.set('target_health_factor', String(targetHealthFactor));
+            return `/risk/collateral_excess_or_deficit?${params.toString()}`;
+        },
+        collateralSimulation: '/risk/collateral_simulation',
+    },
     prices: (symbol) => `/prices/${symbol}`,
     metrics: {
         pnl: (subaccount, startTime, endTime) => `/metrics/pnl?subaccount_address=${(0, ethers_1.getAddress)(subaccount)}${startTime && endTime ? `&start=${startTime}&end=${endTime}` : ''}`,
+        vaultPerformanceFees: (params) => {
+            const q = new URLSearchParams({
+                vault_address: params.vaultAddress,
+                annualized_fees_pct: String(params.annualizedFeesPct),
+                native_denominated: String(params.nativeDenominated),
+                calculation_period: params.calculationPeriod,
+            });
+            if (params.startDate !== undefined)
+                q.set('start_date', params.startDate);
+            if (params.endDate !== undefined)
+                q.set('end_date', params.endDate);
+            return `/metrics/vault_performance_fees?${q.toString()}`;
+        },
     },
     public: {
         integrations: {
@@ -92,6 +159,11 @@ exports.WEBSERVER_ENDPOINTS = {
             unrealizedHistory: (vaultAddress, limit) => `/upshift/unrealized_pnl?vault_address=${vaultAddress}${limit !== undefined ? `&limit=${limit}` : ''}`,
             unrealizedLatest: '/upshift/unrealized_pnl/latest',
         },
+        revertReason: (txHash, chain) => `/revert_reason?${new URLSearchParams({
+            tx_hash: txHash,
+            chain: String(chain),
+        }).toString()}`,
+        oracleClassification: (vaultAddress, chainId) => `/upshift/oracle_classification/${encodeURIComponent(vaultAddress)}?chain_id=${chainId}`,
     },
     upshift: {
         vaults: {

package/lib/core/constants/vaults.d.ts

@@ -20,6 +20,11 @@ export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
         subaccount: IAddress;
         useDebank: boolean;
     };
+    MonarqXRP: {
+        address: IAddress;
+        subaccount: IAddress;
+        useDebank: boolean;
+    };
 };
 /**
  * @deprecated use the backend responses /tokenized_vault internal_type field to determine if the vault is an old lending pool

package/lib/core/constants/vaults.js

@@ -26,6 +26,13 @@ exports.VAULT_ALLOCATION_SUBACCOUNTS = {
         subaccount: (0, ethers_1.getAddress)('0xC8c0Ffb8Ff3BDA26321224e800B3B38AEaB48799'),
         useDebank: true,
     },
+    // For the Monarq XRP Yield Vault (Flare), surface the borrower subaccount and
+    // keep vault-level Debank exposure (mirrors earnAUSD).
+    MonarqXRP: {
+        address: (0, ethers_1.getAddress)('0x2439D4bb753A0f3777d4C9011AFacc475ba6B951'),
+        subaccount: (0, ethers_1.getAddress)('0xF755B2244C1C1f20cA03C3Bb472175C9a4E250f2'),
+        useDebank: true,
+    },
 };
 /**
  * @deprecated use the backend responses /tokenized_vault internal_type field to determine if the vault is an old lending pool

package/lib/core/constants/web3.d.ts

@@ -12,6 +12,23 @@ export declare const SPECIAL_CHAINS: {
     };
 };
 export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/**
+ * 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;
 export declare const MIN_ABIS: {
     name: string;
     symbol: string;

package/lib/core/constants/web3.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
+exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.EVM_NATIVE_DECIMALS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
 // Special Chains
 exports.SPECIAL_CHAINS = {
     solana: {
@@ -16,6 +16,23 @@ exports.SPECIAL_CHAINS = {
 };
 // General
 exports.NATIVE_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+/**
+ * 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.
+ */
+exports.EVM_NATIVE_DECIMALS = 18;
 exports.MIN_ABIS = {
     name: 'function name() view returns (string)',
     symbol: 'function symbol() view returns (string)',

package/lib/core/fetcher.d.ts

@@ -41,6 +41,41 @@ export declare function setSdkRequestTimeout(ms?: number | null): void;
  * otherwise the compiled-in `REQUEST_TIMEOUT_MS`.
  */
 export declare function getSdkRequestTimeout(): number;
+/**
+ * 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;
+/**
+ * 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;
 import { CACHE, getSafeCache, setSafeCache } from './cache';
 export { CACHE, getSafeCache, setSafeCache };
 /**

package/lib/core/fetcher.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSafeCache = exports.getSafeCache = exports.CACHE = void 0;
 exports.setSdkRequestTimeout = setSdkRequestTimeout;
 exports.getSdkRequestTimeout = getSdkRequestTimeout;
+exports.setPublicApiBaseUrl = setPublicApiBaseUrl;
+exports.getPublicApiBaseUrl = getPublicApiBaseUrl;
 exports.fetchAugustWithKey = fetchAugustWithKey;
 exports.fetchAugustPublic = fetchAugustPublic;
 exports.fetchAugustWithBearer = fetchAugustWithBearer;
@@ -73,6 +75,78 @@ function setSdkRequestTimeout(ms = null) {
 function getSdkRequestTimeout() {
     return SDK_REQUEST_TIMEOUT_OVERRIDE ?? core_2.REQUEST_TIMEOUT_MS;
 }
+let PUBLIC_API_BASE_OVERRIDE = null;
+/**
+ * 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.
+ */
+function setPublicApiBaseUrl(url = null) {
+    const previous = PUBLIC_API_BASE_OVERRIDE;
+    if (url === null) {
+        PUBLIC_API_BASE_OVERRIDE = null;
+    }
+    else {
+        let parsed = null;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            parsed = null;
+        }
+        if (!parsed ||
+            (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')) {
+            // Reset to the default rather than retaining a stale prior override, so
+            // each construction stays authoritative and a bad env value fails safe to
+            // prod instead of inheriting another instance's base.
+            logger_1.Logger.log.warn('setPublicApiBaseUrl', 'Ignoring invalid/non-http(s) URL; resetting to the default public base', { url });
+            PUBLIC_API_BASE_OVERRIDE = null;
+        }
+        else {
+            // Store WITHOUT a trailing slash: buildAugustUrl concatenates
+            // `${base}${relativeUrl}` (relativeUrl starts with '/'), so a trailing
+            // slash on the base would produce a double slash.
+            PUBLIC_API_BASE_OVERRIDE = url.replace(/\/+$/, '');
+        }
+    }
+    if (PUBLIC_API_BASE_OVERRIDE !== previous) {
+        // The public base moved (or reset). Drop cached public-catalog responses
+        // keyed against the previous base (see fetchTokenizedVault(s) etc.) so they
+        // aren't served for the new backend.
+        cache_1.CACHE.clear();
+    }
+}
+/**
+ * Read the active base for the `public` server — the SDK-level override if set,
+ * otherwise the compiled-in `WEBSERVER_URL.public`.
+ */
+function getPublicApiBaseUrl() {
+    return PUBLIC_API_BASE_OVERRIDE ?? core_2.WEBSERVER_URL.public;
+}
 /**
  * Combine the per-request timeout signal with any caller-supplied signal.
  * Uses `AbortSignal.any` (Node 22+) with a manual relay fallback.
@@ -182,7 +256,12 @@ const PRICE_REQUESTS = new Map();
  */
 function buildAugustUrl(server, relativeUrl) {
     const serverKey = server;
-    const base = core_2.WEBSERVER_URL[serverKey];
+    // The `public` base is overridable (setPublicApiBaseUrl / IAugustBase
+    // .publicApiBaseUrl) so non-prod deployments can point vault-catalog reads at
+    // an isolated backend. Resolved once here via getPublicApiBaseUrl() (single
+    // source of truth), so the origin check below validates against the OVERRIDDEN
+    // origin.
+    const base = serverKey === 'public' ? getPublicApiBaseUrl() : core_2.WEBSERVER_URL[serverKey];
     if (!base) {
         throw new errors_1.AugustValidationError('INVALID_URL', `Unknown August server "${String(server)}". Expected one of: ${Object.keys(core_2.WEBSERVER_URL).join(', ')}`);
     }

package/lib/main.js

@@ -111,7 +111,7 @@ class AugustSDK extends core_1.AugustBase {
         this.stellar = new stellar_1.default();
         this.vaults = new vaults_1.AugustVaults(baseConfig, this.solana, this.sui);
         this.subaccounts = new sub_accounts_1.AugustSubAccounts(baseConfig);
-        this.api = new api_1.AugustApi();
+        this.api = new api_1.AugustApi(baseConfig);
         // Instrument all SDK methods for analytics tracking
         (0, analytics_1.instrumentClass)(this, () => this.activeNetwork?.chainId);
         (0, analytics_1.instrumentClass)(this.evm, () => this.activeNetwork?.chainId);

package/lib/modules/api/fetcher.d.ts

@@ -0,0 +1,82 @@
+import { type IFetchAugustOptions } from '../../core';
+import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
+/**
+ * Fetch the global loan-book aggregate (admin-only `GET /dashboard/loans`).
+ */
+export declare const fetchDashboardLoans: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ILoanBookInfo[]>;
+/**
+ * Fetch every token discount-factor ladder (`GET /risk/discount_factors`).
+ */
+export declare const fetchDiscountFactors: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IDiscountFactorLadder[]>;
+/**
+ * Fetch a subaccount's collateral excess/deficit for one token
+ * (`GET /risk/collateral_excess_or_deficit`).
+ */
+export declare const fetchCollateralExcessOrDeficit: (params: {
+    subaccount: string;
+    tokenAddress: string;
+    tokenChain: number;
+    targetHealthFactor?: number;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICollateralExcessOrDeficit>;
+/**
+ * Run a collateral simulation (`POST /risk/collateral_simulation`). This is a
+ * pure, read-only simulation — the backend computes required collateral for a
+ * hypothetical loan and changes no state.
+ */
+export declare const fetchCollateralSimulation: (body: ICollateralSimulationInput, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICollateralSimulationResults>;
+/**
+ * Fetch the decoded revert reason(s) for a transaction from the public
+ * `GET /revert_reason` endpoint. No API key required.
+ */
+export declare const fetchRevertReason: (txHash: string, chain: number, headers?: IFetchAugustOptions["headers"]) => Promise<IRevertReason>;
+/**
+ * Fetch all OTC positions (admin-only `GET /otc/position`).
+ */
+export declare const fetchOtcPositions: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IOtcPositionRead[]>;
+/**
+ * Fetch OTC margin requirements (admin-only `GET /otc/margin_requirement`),
+ * optionally filtered by counterparty id and/or payer.
+ */
+export declare const fetchOtcMarginRequirements: (filters: {
+    otcCounterpartyId?: string;
+    payer?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IOtcMarginRequirement[]>;
+/**
+ * Fetch the subaccounts linked to a vault (curator-or-admin
+ * `GET /curator/vaults/{vault_address}/subaccounts`).
+ */
+export declare const fetchCuratorVaultSubaccounts: (vaultAddress: string, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubaccountListItem[]>;
+/**
+ * Fetch on-chain whitelist status for a vault's subaccounts (curator-or-admin
+ * `GET /curator/vaults/{vault_address}/whitelist`). EVM vaults only — the
+ * backend 400s for non-EVM vaults.
+ */
+export declare const fetchCuratorVaultWhitelist: (vaultAddress: string, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICuratorWhitelistStatus[]>;
+/**
+ * Fetch timelock requests for a vault on a chain (`GET /timelock-requests`),
+ * optionally filtered by status.
+ */
+export declare const fetchTimelockRequests: (params: {
+    vaultAddress: string;
+    chainId: number;
+    status?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ITimelockRequest[]>;
+/**
+ * Fetch a vault's performance-fee computation
+ * (`GET /metrics/vault_performance_fees`). Slow first call (pandas over full
+ * snapshot history); 20-minute server-side cache.
+ */
+export declare const fetchVaultPerformanceFees: (params: {
+    vaultAddress: string;
+    annualizedFeesPct: number;
+    nativeDenominated: boolean;
+    calculationPeriod: string;
+    startDate?: string;
+    endDate?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IVaultPerformanceFees>;
+/**
+ * Fetch a vault's NAV-oracle classification table from the public
+ * `GET /upshift/oracle_classification/{vault_address}` endpoint. No API key
+ * required.
+ */
+export declare const fetchVaultOracleClassification: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<IOracleClassification>;