@augustdigital/sdk 8.8.0 → 8.10.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.8.0";
+export declare const SDK_VERSION = "8.10.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.8.0';
+exports.SDK_VERSION = '8.10.0';
 //# sourceMappingURL=version.js.map

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/helpers/chain-error.d.ts

@@ -45,6 +45,7 @@ export declare function isUserRejectionError(error: unknown): boolean;
  * ```
  */
 export declare function isExpectedRevertError(error: unknown): boolean;
+export declare function isInsufficientFundsError(error: unknown): boolean;
 /**
  * Log a caught chain error at the severity its category warrants, without
  * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`

package/lib/core/helpers/chain-error.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUserRejectionError = isUserRejectionError;
 exports.isExpectedRevertError = isExpectedRevertError;
+exports.isInsufficientFundsError = isInsufficientFundsError;
 exports.logChainError = logChainError;
 const logger_1 = require("../logger");
 /**
@@ -21,6 +22,9 @@ const logger_1 = require("../logger");
  * 2. **Expected on-chain read reverts** — reading a function a vault doesn't
  *    implement, or an address with no/incompatible bytecode, reverts. This is a
  *    routine outcome of probing heterogeneous vaults, not a defect.
+ * 3. **Underfunded sender accounts** — the node rejects the transaction because
+ *    the sender can't cover gas (or, on rollups such as Citrea, the extra L1
+ *    data-availability fee). This is a "top up your wallet" prompt, not a bug.
  *
  * These predicates let call sites demote exactly those cases to `warn` while
  * leaving genuine failures at `error`. They are intentionally dependency-free
@@ -77,6 +81,39 @@ function errorCodes(error) {
     }
     return codes;
 }
+/**
+ * Collect every human-readable message string an error-like value carries,
+ * across the nested locations providers stash them in.
+ *
+ * Why this is separate from {@link errorText}: ethers v6 flattens a rejected
+ * `eth_estimateGas`/`eth_call` to a generic *top-level* `message` (e.g.
+ * `"missing revert data"`) while preserving the node's original JSON-RPC error
+ * one level down at `info.error.message`. The real reason (an insufficient-funds
+ * report, say) is therefore invisible to a top-level `.message` read. We scan
+ * the top-level message plus `error.message`, `info.error.message`,
+ * `cause.message`, and `cause.info.error.message` so a caller catches the reason
+ * whether it holds the raw provider error or an SDK error that wrapped it as
+ * `cause`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns Every non-empty message string found (possibly empty array).
+ */
+function nestedMessages(error) {
+    const out = [];
+    const push = (value) => {
+        if (typeof value === 'string' && value.length > 0)
+            out.push(value);
+    };
+    push(errorText(error));
+    if (error && typeof error === 'object') {
+        const e = error;
+        push(e.error?.message);
+        push(e.info?.error?.message);
+        push(e.cause?.message);
+        push(e.cause?.info?.error?.message);
+    }
+    return out;
+}
 /**
  * Is this error a wallet/user rejection of a transaction or signature request?
  *
@@ -143,6 +180,65 @@ function isExpectedRevertError(error) {
         msg.includes('call revert exception') ||
         msg.includes('reverted'));
 }
+/**
+ * Is this error the chain node reporting that the sender can't afford the
+ * transaction's gas/fee — i.e. the account needs topping up, not a defect?
+ *
+ * This is distinct from a contract revert, and easy to misclassify. When the
+ * node rejects `eth_estimateGas` for an underfunded account, ethers v6 discards
+ * the node's reason and surfaces a generic `CALL_EXCEPTION` / `"missing revert
+ * data"` at the top level — which {@link isExpectedRevertError} matches. The
+ * real reason survives only in the nested JSON-RPC error, so this predicate
+ * scans there (via `nestedMessages`). On a write path, check this **before**
+ * {@link isExpectedRevertError}, or a genuine funds shortfall reads as a benign
+ * revert.
+ *
+ * Matching is anchored to the node's pre-execution funds-check phrasings (see
+ * `INSUFFICIENT_FUNDS_PHRASES`), each of which carries a `for <purpose>`
+ * qualifier — `insufficient funds for gas`, `insufficient funds for transfer`,
+ * `not enough funds for L1 fee` (Citrea's data-availability fee), etc. This is
+ * deliberately narrower than a bare `"insufficient funds"` substring: a
+ * *contract revert reason* that merely contains the word "funds" (e.g.
+ * `execution reverted: insufficient funds in pool`) must stay a genuine failure,
+ * not be demoted to an ACCOUNT_NOT_FUNDED "top up gas" prompt.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an unfunded/underfunded sender account.
+ *
+ * @example
+ * ```ts
+ * try { await vault.requestRedeem(...); }
+ * catch (e) {
+ *   if (isInsufficientFundsError(e))
+ *     throw new AugustValidationError(
+ *       'ACCOUNT_NOT_FUNDED',
+ *       'Add gas to continue',
+ *       { cause: e },
+ *     );
+ *   throw e;
+ * }
+ * ```
+ */
+/**
+ * The node pre-execution funds-check phrasings {@link isInsufficientFundsError}
+ * recognises, lower-cased. Each keeps the `for <purpose>` qualifier so the match
+ * is anchored to a funding rejection and can't be tripped by a contract revert
+ * reason that merely mentions "funds". `insufficient funds for gas` covers the
+ * geth/reth `"... for gas * price + value"` message; `not enough funds for l1
+ * fee` is the rollup (Citrea) data-availability-fee shortfall.
+ */
+const INSUFFICIENT_FUNDS_PHRASES = [
+    'insufficient funds for gas',
+    'insufficient funds for transfer',
+    'insufficient funds for intrinsic transaction cost',
+    'not enough funds for l1 fee',
+];
+function isInsufficientFundsError(error) {
+    return nestedMessages(error).some((raw) => {
+        const msg = raw.toLowerCase();
+        return INSUFFICIENT_FUNDS_PHRASES.some((phrase) => msg.includes(phrase));
+    });
+}
 /**
  * Log a caught chain error at the severity its category warrants, without
  * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`

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>;

package/lib/modules/api/fetcher.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultOracleClassification = exports.fetchVaultPerformanceFees = exports.fetchTimelockRequests = exports.fetchCuratorVaultWhitelist = exports.fetchCuratorVaultSubaccounts = exports.fetchOtcMarginRequirements = exports.fetchOtcPositions = exports.fetchRevertReason = exports.fetchCollateralSimulation = exports.fetchCollateralExcessOrDeficit = exports.fetchDiscountFactors = exports.fetchDashboardLoans = void 0;
+const core_1 = require("../../core");
+/**
+ * Fetch the global loan-book aggregate (admin-only `GET /dashboard/loans`).
+ */
+const fetchDashboardLoans = async (augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.dashboard.loans, { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch dashboard loans: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchDashboardLoans = fetchDashboardLoans;
+/**
+ * Fetch every token discount-factor ladder (`GET /risk/discount_factors`).
+ */
+const fetchDiscountFactors = async (augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.risk.discountFactors, { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch discount factors: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchDiscountFactors = fetchDiscountFactors;
+/**
+ * Fetch a subaccount's collateral excess/deficit for one token
+ * (`GET /risk/collateral_excess_or_deficit`).
+ */
+const fetchCollateralExcessOrDeficit = async (params, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.risk.collateralExcessOrDeficit(params.subaccount, params.tokenAddress, params.tokenChain, params.targetHealthFactor), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch collateral excess or deficit: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchCollateralExcessOrDeficit = fetchCollateralExcessOrDeficit;
+/**
+ * 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.
+ */
+const fetchCollateralSimulation = async (body, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.risk.collateralSimulation, { method: 'post', data: body, headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to run collateral simulation: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchCollateralSimulation = fetchCollateralSimulation;
+/**
+ * Fetch the decoded revert reason(s) for a transaction from the public
+ * `GET /revert_reason` endpoint. No API key required.
+ */
+const fetchRevertReason = async (txHash, chain, headers) => {
+    const response = await (0, core_1.fetchAugustPublic)(core_1.WEBSERVER_ENDPOINTS.public.revertReason(txHash, chain), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch revert reason: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchRevertReason = fetchRevertReason;
+/**
+ * Fetch all OTC positions (admin-only `GET /otc/position`).
+ */
+const fetchOtcPositions = async (augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.otc.positions, { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch OTC positions: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchOtcPositions = fetchOtcPositions;
+/**
+ * Fetch OTC margin requirements (admin-only `GET /otc/margin_requirement`),
+ * optionally filtered by counterparty id and/or payer.
+ */
+const fetchOtcMarginRequirements = async (filters, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.otc.marginRequirements(filters.otcCounterpartyId, filters.payer), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch OTC margin requirements: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchOtcMarginRequirements = fetchOtcMarginRequirements;
+/**
+ * Fetch the subaccounts linked to a vault (curator-or-admin
+ * `GET /curator/vaults/{vault_address}/subaccounts`).
+ */
+const fetchCuratorVaultSubaccounts = async (vaultAddress, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.curator.vaultSubaccounts(vaultAddress), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch curator vault subaccounts: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchCuratorVaultSubaccounts = fetchCuratorVaultSubaccounts;
+/**
+ * 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.
+ */
+const fetchCuratorVaultWhitelist = async (vaultAddress, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.curator.vaultWhitelist(vaultAddress), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch curator vault whitelist: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchCuratorVaultWhitelist = fetchCuratorVaultWhitelist;
+/**
+ * Fetch timelock requests for a vault on a chain (`GET /timelock-requests`),
+ * optionally filtered by status.
+ */
+const fetchTimelockRequests = async (params, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.timelockRequests(params.vaultAddress, params.chainId, params.status), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch timelock requests: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchTimelockRequests = fetchTimelockRequests;
+/**
+ * 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.
+ */
+const fetchVaultPerformanceFees = async (params, augustKey, headers) => {
+    const response = await (0, core_1.fetchAugustWithKey)(augustKey, core_1.WEBSERVER_ENDPOINTS.metrics.vaultPerformanceFees(params), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch vault performance fees: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchVaultPerformanceFees = fetchVaultPerformanceFees;
+/**
+ * Fetch a vault's NAV-oracle classification table from the public
+ * `GET /upshift/oracle_classification/{vault_address}` endpoint. No API key
+ * required.
+ */
+const fetchVaultOracleClassification = async (vaultAddress, chainId, headers) => {
+    const response = await (0, core_1.fetchAugustPublic)(core_1.WEBSERVER_ENDPOINTS.public.oracleClassification(vaultAddress, chainId), { headers });
+    if (!response.ok || typeof response.json !== 'function') {
+        throw new Error(`Failed to fetch vault oracle classification: ${response.statusText || 'Unknown error'}`);
+    }
+    return response.json();
+};
+exports.fetchVaultOracleClassification = fetchVaultOracleClassification;
+//# sourceMappingURL=fetcher.js.map