@augustdigital/sdk 8.8.0 → 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.8.0";
+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.8.0';
+exports.SDK_VERSION = '8.9.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/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