@augustdigital/sdk 8.24.0 → 8.25.0

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

@@ -36,6 +36,16 @@ exports.METHOD_CATEGORIES = {
     getTimelockRequests: 'read.vault',
     getVaultPerformanceFees: 'read.vault',
     getVaultOracleClassification: 'read.vault',
+    // Transparency dashboard (one per card/tab)
+    getVaultPositionSnapshot: 'read.vault',
+    getVaultBackingSeries: 'read.vault',
+    getVaultSmoothedApy: 'read.vault',
+    getVaultHistoricalAllocations: 'read.vault',
+    getVaultFeeConfig: 'read.vault',
+    getVaultGovernanceRoles: 'read.vault',
+    getVaultGovernancePermissions: 'read.vault',
+    getVaultGovernanceTimelocks: 'read.vault',
+    getVaultGovernanceAuditLog: 'read.vault',
     getVaultBorrowerHealthFactor: 'read.vault',
     getYieldLastRealizedOn: 'read.vault',
     getVaultActivity: 'read.vault',

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.24.0";
+export declare const SDK_VERSION = "8.25.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.24.0';
+exports.SDK_VERSION = '8.25.0';
 //# sourceMappingURL=version.js.map

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

@@ -117,6 +117,17 @@ export declare const WEBSERVER_ENDPOINTS: {
         };
         revertReason: (txHash: string, chain: number) => string;
         oracleClassification: (vaultAddress: string, chainId: number) => string;
+        transparency: {
+            positions: (vaultAddress: string, chainId: number) => string;
+            historicalAllocations: (vaultAddress: string, chainId: number, startDate?: string, endDate?: string) => string;
+            fees: (vaultAddress: string, chainId: number) => string;
+            ratioSeries: (vaultAddress: string, startDate?: string, endDate?: string, limit?: number) => string;
+            smoothedApy: (vaultAddress: string, daysAgo: number, averagingPeriodDays: number, applySmoothing: boolean) => string;
+            governanceRoles: (vaultAddress: string, chainId: number) => string;
+            governancePermissions: (vaultAddress: string, chainId: number) => string;
+            governanceTimelocks: (vaultAddress: string, chainId: number, status?: string) => string;
+            governanceAuditLog: (vaultAddress: string, chainId: number, category?: string, before?: string, limit?: number) => string;
+        };
     };
     upshift: {
         vaults: {

package/lib/core/constants/core.js

@@ -191,6 +191,60 @@ exports.WEBSERVER_ENDPOINTS = {
             chain: String(chain),
         }).toString()}`,
         oracleClassification: (vaultAddress, chainId) => `/upshift/oracle_classification/${encodeURIComponent(vaultAddress)}?chain_id=${chainId}`,
+        // Transparency dashboard endpoints (all public, snapshot-backed).
+        transparency: {
+            positions: (vaultAddress, chainId) => `/upshift/positions/${encodeURIComponent(vaultAddress)}?chain_id=${chainId}`,
+            historicalAllocations: (vaultAddress, chainId, startDate, endDate) => {
+                const q = new URLSearchParams({ chain_id: String(chainId) });
+                if (startDate)
+                    q.set('start_date', startDate);
+                // The backend compares `<= end_date` as a datetime, so a bare date
+                // would exclude the whole last day; widen to end-of-day for the
+                // documented inclusive semantics.
+                if (endDate)
+                    q.set('end_date', `${endDate}T23:59:59.999`);
+                return `/upshift/historical_allocations/${encodeURIComponent(vaultAddress)}?${q.toString()}`;
+            },
+            fees: (vaultAddress, chainId) => `/upshift/fees/${encodeURIComponent(vaultAddress)}?chain_id=${chainId}`,
+            ratioSeries: (vaultAddress, startDate, endDate, limit) => {
+                const q = new URLSearchParams({
+                    vault_address: vaultAddress,
+                    fields: 'ratio',
+                });
+                if (startDate)
+                    q.set('start_date', startDate);
+                // See historicalAllocations: widen to end-of-day for inclusive semantics.
+                if (endDate)
+                    q.set('end_date', `${endDate}T23:59:59.999`);
+                if (limit !== undefined)
+                    q.set('limit', String(limit));
+                return `/upshift/unrealized_pnl?${q.toString()}`;
+            },
+            smoothedApy: (vaultAddress, daysAgo, averagingPeriodDays, applySmoothing) => `/upshift/historical_apy/chart?${new URLSearchParams({
+                vault_address: vaultAddress,
+                days_ago: String(daysAgo),
+                averaging_period_in_days: String(averagingPeriodDays),
+                apply_smoothing: String(applySmoothing),
+            }).toString()}`,
+            governanceRoles: (vaultAddress, chainId) => `/upshift/governance/${encodeURIComponent(vaultAddress)}/roles?chain_id=${chainId}`,
+            governancePermissions: (vaultAddress, chainId) => `/upshift/governance/${encodeURIComponent(vaultAddress)}/permissions?chain_id=${chainId}`,
+            governanceTimelocks: (vaultAddress, chainId, status) => {
+                const q = new URLSearchParams({ chain_id: String(chainId) });
+                if (status)
+                    q.set('status', status);
+                return `/upshift/governance/${encodeURIComponent(vaultAddress)}/timelocks?${q.toString()}`;
+            },
+            governanceAuditLog: (vaultAddress, chainId, category, before, limit) => {
+                const q = new URLSearchParams({ chain_id: String(chainId) });
+                if (category)
+                    q.set('category', category);
+                if (before)
+                    q.set('before', before);
+                if (limit !== undefined)
+                    q.set('limit', String(limit));
+                return `/upshift/governance/${encodeURIComponent(vaultAddress)}/audit_log?${q.toString()}`;
+            },
+        },
     },
     upshift: {
         vaults: {

package/lib/main.d.ts

@@ -41,8 +41,9 @@ export declare class AugustSDK extends AugustBase {
     get vaultsModule(): AugustVaults;
     /**
      * Get the backend API module instance ({@link AugustApi}) — read-only
-     * access to backend-computed data with no on-chain equivalent
-     * (unrealized-PnL series).
+     * access to backend-computed data with no on-chain equivalent: the
+     * unrealized-PnL series and the transparency dashboard (position snapshot,
+     * backing series, smoothed APY, allocations, fee config, governance).
      */
     get apiModule(): AugustApi;
     /**
@@ -119,8 +120,27 @@ export declare class AugustSDK extends AugustBase {
     }): Promise<import("./types").IVaultLoan[]>;
     /**
      * Get vault asset allocations across DeFi protocols, CeFi, and OTC positions.
+     *
+     * This is the data behind the "Vault Exposure" section of the Upshift app —
+     * a partner rendering that section in their own frontend needs only this
+     * call. Read `exposurePerCategory` for the pre-bucketed view the UI renders
+     * (`supplying` / `borrowing` / `wallet` / `lending` legs plus per-category
+     * USD totals) and `netValue` for the headline figure; the raw `defi` /
+     * `cefi` / `otc` arrays back the drill-downs. See the "Rendering the Vault
+     * Exposure section" guide in the vaults docs for a faithful reproduction.
+     *
      * @param props - Vault address and chain ID
      * @returns Detailed breakdown of vault allocations by category
+     * @example
+     * ```ts
+     * const { exposurePerCategory, netValue } = await sdk.getVaultAllocations({
+     *   vault: '0xcd69123b3FBBfC666E1f6a501da27B564C00De54',
+     *   chainId: 1,
+     * });
+     * for (const item of exposurePerCategory?.supplying ?? []) {
+     *   console.log(item.protocol, item.symbol, item.amount);
+     * }
+     * ```
      */
     getVaultAllocations(props: {
         vault: IAddress;

package/lib/main.js

@@ -146,8 +146,9 @@ class AugustSDK extends core_1.AugustBase {
     }
     /**
      * Get the backend API module instance ({@link AugustApi}) — read-only
-     * access to backend-computed data with no on-chain equivalent
-     * (unrealized-PnL series).
+     * access to backend-computed data with no on-chain equivalent: the
+     * unrealized-PnL series and the transparency dashboard (position snapshot,
+     * backing series, smoothed APY, allocations, fee config, governance).
      */
     get apiModule() {
         return this.api;
@@ -242,8 +243,27 @@ class AugustSDK extends core_1.AugustBase {
     }
     /**
      * Get vault asset allocations across DeFi protocols, CeFi, and OTC positions.
+     *
+     * This is the data behind the "Vault Exposure" section of the Upshift app —
+     * a partner rendering that section in their own frontend needs only this
+     * call. Read `exposurePerCategory` for the pre-bucketed view the UI renders
+     * (`supplying` / `borrowing` / `wallet` / `lending` legs plus per-category
+     * USD totals) and `netValue` for the headline figure; the raw `defi` /
+     * `cefi` / `otc` arrays back the drill-downs. See the "Rendering the Vault
+     * Exposure section" guide in the vaults docs for a faithful reproduction.
+     *
      * @param props - Vault address and chain ID
      * @returns Detailed breakdown of vault allocations by category
+     * @example
+     * ```ts
+     * const { exposurePerCategory, netValue } = await sdk.getVaultAllocations({
+     *   vault: '0xcd69123b3FBBfC666E1f6a501da27B564C00De54',
+     *   chainId: 1,
+     * });
+     * for (const item of exposurePerCategory?.supplying ?? []) {
+     *   console.log(item.protocol, item.symbol, item.amount);
+     * }
+     * ```
      */
     async getVaultAllocations(props) {
         return await this.vaults.getVaultAllocations(props);

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

@@ -1,5 +1,5 @@
 import { type IFetchAugustOptions } from '../../core';
-import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
+import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, ITransparencyAuditLog, ITransparencyFees, ITransparencyGovernancePermissions, ITransparencyGovernanceRoles, ITransparencyHistoricalAllocations, ITransparencyPositions, ITransparencyRatioPoint, ITransparencyTimelocks, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
 /**
  * Fetch the global loan-book aggregate (admin-only `GET /dashboard/loans`).
  */
@@ -80,3 +80,29 @@ export declare const fetchVaultPerformanceFees: (params: {
  * required.
  */
 export declare const fetchVaultOracleClassification: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<IOracleClassification>;
+/** Public `GET /upshift/positions/{vault}` — latest per-wallet position snapshot. */
+export declare const fetchTransparencyPositions: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyPositions>;
+/** Public `GET /upshift/historical_allocations/{vault}` — daily per-protocol allocation history. */
+export declare const fetchTransparencyHistoricalAllocations: (vaultAddress: string, chainId: number, startDate?: string, endDate?: string, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyHistoricalAllocations>;
+/** Public `GET /upshift/fees/{vault}` — vault fee configuration. */
+export declare const fetchTransparencyFees: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyFees>;
+/** Public `GET /upshift/unrealized_pnl?fields=ratio` — hourly backing / supply / collateral-ratio series. */
+export declare const fetchTransparencyRatioSeries: (vaultAddress: string, startDate?: string, endDate?: string, limit?: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyRatioPoint[]>;
+/** Public `GET /upshift/historical_apy/chart` — smoothed rolling-APY series; returns the raw backend envelope. */
+export declare const fetchTransparencySmoothedApy: (vaultAddress: string, daysAgo: number, averagingPeriodDays: number, applySmoothing: boolean, headers?: IFetchAugustOptions["headers"]) => Promise<{
+    data: {
+        labels: string[];
+        values: number[];
+    };
+    average_apy?: number | null;
+    status: number;
+    error?: string | null;
+}>;
+/** Public `GET /upshift/governance/{vault}/roles` — owner/operator addresses with custody enrichment. */
+export declare const fetchTransparencyGovernanceRoles: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyGovernanceRoles>;
+/** Public `GET /upshift/governance/{vault}/permissions` — whitelisted integrations per vault wallet. */
+export declare const fetchTransparencyGovernancePermissions: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyGovernancePermissions>;
+/** Public `GET /upshift/governance/{vault}/timelocks` — timelock queue, default pending only. */
+export declare const fetchTransparencyGovernanceTimelocks: (vaultAddress: string, chainId: number, status?: string, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyTimelocks>;
+/** Public `GET /upshift/governance/{vault}/audit_log` — one page of the governance audit log. */
+export declare const fetchTransparencyGovernanceAuditLog: (vaultAddress: string, chainId: number, category?: string, before?: string, limit?: number, headers?: IFetchAugustOptions["headers"]) => Promise<ITransparencyAuditLog>;

package/lib/modules/api/fetcher.js

@@ -1,6 +1,6 @@
 "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;
+exports.fetchTransparencyGovernanceAuditLog = exports.fetchTransparencyGovernanceTimelocks = exports.fetchTransparencyGovernancePermissions = exports.fetchTransparencyGovernanceRoles = exports.fetchTransparencySmoothedApy = exports.fetchTransparencyRatioSeries = exports.fetchTransparencyFees = exports.fetchTransparencyHistoricalAllocations = exports.fetchTransparencyPositions = 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`).
@@ -147,4 +147,41 @@ const fetchVaultOracleClassification = async (vaultAddress, chainId, headers) =>
     return response.json();
 };
 exports.fetchVaultOracleClassification = fetchVaultOracleClassification;
+/**
+ * Shared GET for the public transparency-dashboard endpoints. One HTTPS
+ * request, no RPC. `fetchAugustPublic` already maps non-2xx to typed
+ * `AugustServerError` / `AugustRateLimitError` / `AugustTimeoutError`, so
+ * this only parses the body; validation happens in the module layer.
+ */
+const fetchTransparency = async (endpoint, headers) => {
+    const response = await (0, core_1.fetchAugustPublic)(endpoint, { headers });
+    return response.json();
+};
+/** Public `GET /upshift/positions/{vault}` — latest per-wallet position snapshot. */
+const fetchTransparencyPositions = (vaultAddress, chainId, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.positions(vaultAddress, chainId), headers);
+exports.fetchTransparencyPositions = fetchTransparencyPositions;
+/** Public `GET /upshift/historical_allocations/{vault}` — daily per-protocol allocation history. */
+const fetchTransparencyHistoricalAllocations = (vaultAddress, chainId, startDate, endDate, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.historicalAllocations(vaultAddress, chainId, startDate, endDate), headers);
+exports.fetchTransparencyHistoricalAllocations = fetchTransparencyHistoricalAllocations;
+/** Public `GET /upshift/fees/{vault}` — vault fee configuration. */
+const fetchTransparencyFees = (vaultAddress, chainId, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.fees(vaultAddress, chainId), headers);
+exports.fetchTransparencyFees = fetchTransparencyFees;
+/** Public `GET /upshift/unrealized_pnl?fields=ratio` — hourly backing / supply / collateral-ratio series. */
+const fetchTransparencyRatioSeries = (vaultAddress, startDate, endDate, limit, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.ratioSeries(vaultAddress, startDate, endDate, limit), headers);
+exports.fetchTransparencyRatioSeries = fetchTransparencyRatioSeries;
+/** Public `GET /upshift/historical_apy/chart` — smoothed rolling-APY series; returns the raw backend envelope. */
+const fetchTransparencySmoothedApy = (vaultAddress, daysAgo, averagingPeriodDays, applySmoothing, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.smoothedApy(vaultAddress, daysAgo, averagingPeriodDays, applySmoothing), headers);
+exports.fetchTransparencySmoothedApy = fetchTransparencySmoothedApy;
+/** Public `GET /upshift/governance/{vault}/roles` — owner/operator addresses with custody enrichment. */
+const fetchTransparencyGovernanceRoles = (vaultAddress, chainId, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.governanceRoles(vaultAddress, chainId), headers);
+exports.fetchTransparencyGovernanceRoles = fetchTransparencyGovernanceRoles;
+/** Public `GET /upshift/governance/{vault}/permissions` — whitelisted integrations per vault wallet. */
+const fetchTransparencyGovernancePermissions = (vaultAddress, chainId, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.governancePermissions(vaultAddress, chainId), headers);
+exports.fetchTransparencyGovernancePermissions = fetchTransparencyGovernancePermissions;
+/** Public `GET /upshift/governance/{vault}/timelocks` — timelock queue, default pending only. */
+const fetchTransparencyGovernanceTimelocks = (vaultAddress, chainId, status, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.governanceTimelocks(vaultAddress, chainId, status), headers);
+exports.fetchTransparencyGovernanceTimelocks = fetchTransparencyGovernanceTimelocks;
+/** Public `GET /upshift/governance/{vault}/audit_log` — one page of the governance audit log. */
+const fetchTransparencyGovernanceAuditLog = (vaultAddress, chainId, category, before, limit, headers) => fetchTransparency(core_1.WEBSERVER_ENDPOINTS.public.transparency.governanceAuditLog(vaultAddress, chainId, category, before, limit), headers);
+exports.fetchTransparencyGovernanceAuditLog = fetchTransparencyGovernanceAuditLog;
 //# sourceMappingURL=fetcher.js.map

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

@@ -1,21 +1,16 @@
 import { AugustBase, type IAugustBase } from '../../core/base.class';
-import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, IUnrealizedPnlSnapshot, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
+import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, ITransparencyApySeries, ITransparencyAuditCategory, ITransparencyAuditLog, ITransparencyFees, ITransparencyGovernancePermissions, ITransparencyGovernanceRoles, ITransparencyHistoricalAllocations, ITransparencyPositions, ITransparencyRatioPoint, ITransparencyTimelocks, ITransparencyTimelockStatus, IUnrealizedPnlSnapshot, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
 /**
  * Read-only client for August backend REST endpoints that have no on-chain
- * equivalent — currently the unrealized-PnL series the backend computes
- * from periodic vault snapshots.
+ * equivalent: the unrealized-PnL series, the transparency dashboard
+ * (position snapshot, backing series, smoothed APY, allocations, fee config,
+ * governance), plus authenticated loan-book / risk / OTC reads.
  *
- * Every method makes exactly one HTTPS request to the public
- * (unauthenticated) August API and zero RPC calls. Responses are not cached
- * by the SDK: this is time-sensitive PnL state where staleness is worse
- * than request latency.
- *
- * 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.
+ * Every public method makes exactly one HTTPS request to the August API and
+ * zero RPC calls. Responses are not cached by the SDK: this is time-sensitive
+ * state where staleness is worse than a request. Accessible as
+ * `sdk.apiModule`; only the unrealized-PnL methods are also mirrored on the
+ * root `AugustSDK` class.
  */
 export declare class AugustApi extends AugustBase {
     private headers;
@@ -274,6 +269,285 @@ export declare class AugustApi extends AugustBase {
      *   console.log(cls.warnings);
      */
     getVaultOracleClassification(vault: string, chainId: number): Promise<IOracleClassification>;
+    /**
+     * Fetch the latest position snapshot for a vault, grouped per wallet — the
+     * data behind the transparency Overview tab (strategy breakdown, backing
+     * composition, vault buffer, per-wallet table, headline TVL).
+     *
+     * Public `GET /upshift/positions/{vault_address}`; no API key. One HTTPS
+     * request, no RPC. Snapshots land hourly; every field is from the single
+     * `snapshot_at` instant. Vault buffer = `total_nav − Σ subaccounts[].total_usd`;
+     * `reported_tvl` is the vault-contract-reported total assets from the same snapshot.
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id the vault lives on.
+     * @returns {@link ITransparencyPositions}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const p = await sdk.apiModule.getVaultPositionSnapshot({ vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA', chainId: 143 });
+     * const buffer = p.total_nav - p.subaccounts.reduce((a, s) => a + s.total_usd, 0);
+     * ```
+     */
+    getVaultPositionSnapshot(params: {
+        vault: string;
+        chainId: number;
+    }): Promise<ITransparencyPositions>;
+    /**
+     * Fetch the backing / supply / collateral-ratio time series behind the
+     * Performance tab's "Backing vs Supply" and "Collateral Ratio" charts, and
+     * the Overview sidebar's 7-day deltas.
+     *
+     * Public `GET /upshift/unrealized_pnl?fields=ratio`; no API key. One HTTPS
+     * request, no RPC. Points are hourly, returned newest-first — sort before
+     * charting. `actual_tvl` = backing (mark-to-market), `tvl_on_vault` = supply
+     * (vault-reported), `adjusted_redeem_ratio` = collateral ratio.
+     *
+     * Unlike the chain-scoped transparency endpoints (positions, fees,
+     * governance…), this one is keyed by vault address only and accepts
+     * non-EVM (Solana / Stellar) vaults — same contract as
+     * {@link AugustApi.getVaultUnrealizedPnlHistory}, which it shares a route with.
+     *
+     * @param params.vault Vault address (EVM, Solana, or Stellar).
+     * @param params.startDate Optional inclusive lower bound, `YYYY-MM-DD`.
+     * @param params.endDate Optional inclusive upper bound, `YYYY-MM-DD`.
+     * @param params.limit Optional max points.
+     * @returns Array of {@link ITransparencyRatioPoint}; empty when no history.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const pts = await sdk.apiModule.getVaultBackingSeries({ vault, startDate: '2026-08-01' });
+     * const ratio = pts.map((p) => p.adjusted_redeem_ratio * 100); // percent
+     * ```
+     */
+    getVaultBackingSeries(params: {
+        vault: string;
+        startDate?: string;
+        endDate?: string;
+        limit?: number;
+    }): Promise<ITransparencyRatioPoint[]>;
+    /**
+     * Fetch the smoothed 7-day APY series — the exact series the Upshift app
+     * charts (Overview "APY last 30 days" and Performance "APY Over Time").
+     *
+     * Public `GET /upshift/historical_apy/chart`; no API key. One HTTPS request,
+     * no RPC. The backend marks this route deprecated in its OpenAPI spec but it
+     * remains the series the Upshift app itself charts; this wrapper tracks it.
+     * The backend applies a rolling-median/mean smoothing filter server-side
+     * when `applySmoothing` is true (the app default); computing APY locally from
+     * raw share ratios will NOT match the published figures.
+     *
+     * Unlike the chain-scoped transparency endpoints (positions, fees,
+     * governance…), this one is keyed by vault address only and accepts
+     * non-EVM (Solana / Stellar) vaults.
+     *
+     * @param params.vault Vault address (EVM, Solana, or Stellar).
+     * @param params.daysAgo Window length in days; pass `-1` for the full history since inception. Default 30.
+     * @param params.averagingPeriodDays Rolling window for the annualized return; must be ≥ 2. Default 7 (the app's "7D APY").
+     * @param params.applySmoothing Apply the backend smoothing filter. Default true.
+     * @returns {@link ITransparencyApySeries} — `labels` are `M/D/YYYY`, `values` are decimal fractions (0.0245 = 2.45%). Empty arrays when the vault has no data.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const apy = await sdk.apiModule.getVaultSmoothedApy({ vault, daysAgo: 30 });
+     * console.log(apy.values.at(-1)); // latest 7D APY as a fraction
+     * ```
+     */
+    getVaultSmoothedApy(params: {
+        vault: string;
+        daysAgo?: number;
+        averagingPeriodDays?: number;
+        applySmoothing?: boolean;
+    }): Promise<ITransparencyApySeries>;
+    /**
+     * Fetch daily allocation history per protocol — the Performance tab's
+     * "Allocation Over Time" chart.
+     *
+     * Public `GET /upshift/historical_allocations/{vault_address}`; no API key.
+     * One HTTPS request, no RPC.
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @param params.startDate Optional inclusive lower bound, `YYYY-MM-DD`.
+     * @param params.endDate Optional inclusive upper bound, `YYYY-MM-DD`.
+     * @returns {@link ITransparencyHistoricalAllocations}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const h = await sdk.apiModule.getVaultHistoricalAllocations({ vault, chainId: 143, startDate: '2026-08-01' });
+     * const byDate = Map.groupBy(h.points, (p) => p.date);
+     * ```
+     */
+    getVaultHistoricalAllocations(params: {
+        vault: string;
+        chainId: number;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<ITransparencyHistoricalAllocations>;
+    /**
+     * Fetch a vault's fee configuration — the Performance tab's fee card.
+     *
+     * Public `GET /upshift/fees/{vault_address}`; no API key. One HTTPS
+     * request, no RPC. Percent fields are already scaled (`management_fee_pct`
+     * of `1.5` means 1.5%).
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @returns {@link ITransparencyFees}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const fees = await sdk.apiModule.getVaultFeeConfig({ vault, chainId: 143 });
+     * console.log(`${fees.management_fee_pct}% mgmt / ${fees.performance_fee_pct}% perf`);
+     * ```
+     */
+    getVaultFeeConfig(params: {
+        vault: string;
+        chainId: number;
+    }): Promise<ITransparencyFees>;
+    /**
+     * Fetch the vault's privileged addresses (owner / operators) with custody
+     * enrichment — the Governance tab's "Vault Roles" card.
+     *
+     * Public `GET /upshift/governance/{vault_address}/roles`; no API key. One
+     * HTTPS request from the SDK (the backend performs the on-chain reads).
+     * Third-party enrichment failures (Safe / Fordefi) degrade rows and append
+     * to `warnings` rather than failing.
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @returns {@link ITransparencyGovernanceRoles}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const { roles, warnings } = await sdk.apiModule.getVaultGovernanceRoles({ vault, chainId: 143 });
+     * const owner = roles.find((r) => r.role === 'owner'); // owner?.is_safe → Safe threshold in safe_threshold
+     * ```
+     */
+    getVaultGovernanceRoles(params: {
+        vault: string;
+        chainId: number;
+    }): Promise<ITransparencyGovernanceRoles>;
+    /**
+     * Fetch the integrations each vault wallet is whitelisted to operate —
+     * the Governance tab's "Vault Permissions" table.
+     *
+     * Public `GET /upshift/governance/{vault_address}/permissions`; no API key.
+     * One HTTPS request, no RPC.
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @returns {@link ITransparencyGovernancePermissions}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const { permissions } = await sdk.apiModule.getVaultGovernancePermissions({ vault, chainId: 143 });
+     * for (const p of permissions) console.log(p.integration, p.functions.join(','));
+     * ```
+     */
+    getVaultGovernancePermissions(params: {
+        vault: string;
+        chainId: number;
+    }): Promise<ITransparencyGovernancePermissions>;
+    /**
+     * Fetch the vault's timelock queue — the Governance tab's "Pending
+     * Timelocks" table. Defaults to pending (`scheduled`) requests.
+     *
+     * Public `GET /upshift/governance/{vault_address}/timelocks`; no API key.
+     * `executable_at` is `scheduled_at + TIMELOCK_DURATION()` read live from
+     * the timelock contract; null (plus a warning) when that read failed.
+     * The default filter is pending only — the list is often empty; pass
+     * `status: 'all'` for history. `getTimelockRequests` returns the raw
+     * backend rows; this returns the dashboard view (labels, `executable_at`,
+     * warnings).
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @param params.status Filter: a single {@link ITransparencyTimelockStatus} or `'all'`. Default `'scheduled'`. Any other string is rejected with `AugustValidationError` before a request is made.
+     * @returns {@link ITransparencyTimelocks}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * const { timelocks } = await sdk.apiModule.getVaultGovernanceTimelocks({ vault, chainId: 1 }); // pending only
+     * const ready = timelocks.filter((t) => t.executable_at && Date.parse(`${t.executable_at}Z`) <= Date.now());
+     * ```
+     */
+    getVaultGovernanceTimelocks(params: {
+        vault: string;
+        chainId: number;
+        status?: ITransparencyTimelockStatus | 'all';
+    }): Promise<ITransparencyTimelocks>;
+    /**
+     * Fetch one page of the vault's governance audit log, newest first — the
+     * Governance tab's "Audit Log" timeline. Merges live timelock events with
+     * manually recorded entries (attestations, permission changes).
+     *
+     * Public `GET /upshift/governance/{vault_address}/audit_log`; no API key.
+     * Paginate with `before` = the last returned entry's `timestamp` while
+     * `has_more` is true (exclusive cursor; ties at the exact boundary
+     * timestamp are skipped, never duplicated).
+     *
+     * @param params.vault EVM vault address.
+     * @param params.chainId Numeric chain id.
+     * @param params.category Optional {@link ITransparencyAuditCategory} filter. Any other string is rejected with `AugustValidationError` before a request is made.
+     * @param params.before Optional exclusive cursor — pass the previous page's last `entry.timestamp` back verbatim (naive-UTC, no offset).
+     * @param params.limit Page size, 1–200. Backend default 50.
+     * @returns {@link ITransparencyAuditLog}.
+     * @throws AugustValidationError When arguments fail validation (no request is made).
+     * @throws AugustServerError When the API responds non-2xx (e.g. unknown vault 404, non-EVM vault 422).
+     * @throws AugustServerError (status 200) When the body is not the documented shape — backend contract drift.
+     * @throws AugustRateLimitError When the API responds 429.
+     * @throws AugustTimeoutError When the request exceeds the SDK request timeout.
+     * @example
+     * ```ts
+     * // Walk the whole log, newest first.
+     * let before: string | undefined;
+     * do {
+     *   const page = await sdk.apiModule.getVaultGovernanceAuditLog({ vault, chainId: 1, before, limit: 50 });
+     *   for (const e of page.entries) console.log(e.timestamp, e.type, e.summary);
+     *   before = page.has_more ? page.entries.at(-1)?.timestamp : undefined;
+     * } while (before);
+     * ```
+     */
+    getVaultGovernanceAuditLog(params: {
+        vault: string;
+        chainId: number;
+        category?: ITransparencyAuditCategory;
+        before?: string;
+        limit?: number;
+    }): Promise<ITransparencyAuditLog>;
     /**
      * Fetch the historical unrealized-PnL series for a vault, newest first,
      * as computed by the August backend from periodic vault snapshots.