@augustdigital/sdk 8.7.2 → 8.9.0

package/lib/services/subgraph/vaults.js

@@ -55,7 +55,60 @@ function alertMissingSubgraphOnce(args) {
 function needsMonadSuffix(chainId, symbol) {
     return chainId === 143 && symbol.toLowerCase() === 'earnausd';
 }
-function transformUserHistory(data, chainId, decimals, poolAddress) {
+/**
+ * Read the decimals of every distinct deposit asset in a batch of deposit
+ * rows, keyed by lowercased token address.
+ *
+ * Pre-deposit / evm-2 vaults accept multiple deposit assets whose decimals can
+ * differ from the vault's own (e.g. RLUSD at 18 deposited into a 6-decimal
+ * sentUSD vault). `transformUserHistory` must normalize each deposit against
+ * its own asset's decimals rather than the vault's, or an 18-decimal amount
+ * normalized at 6 decimals renders ~1e12× too large (a 0.5 deposit shows as
+ * "500B"). `getDecimals` is cached and in-flight-deduped, and the distinct-asset
+ * set is tiny (typically 1-3), so this is at most a handful of RPC reads.
+ *
+ * Native-token deposits carry a sentinel `assetIn` — either the zero address or
+ * {@link NATIVE_ADDRESS} — that has no on-chain `decimals()`. These are mapped
+ * directly to {@link EVM_NATIVE_DECIMALS} (18 on every supported EVM chain)
+ * instead of being read. Without this guard `getDecimals(ZeroAddress)` returns
+ * `0`, which the caller's `?? decimals` fallback cannot override (0 is not
+ * nullish), overstating a native deposit ~1e18×; and `getDecimals(NATIVE_ADDRESS)`
+ * reverts, silently dropping to the vault's decimals which may differ.
+ *
+ * Only successfully-read decimals are entered in the map; a non-native asset
+ * whose `decimals()` read fails is omitted so the caller falls back to the
+ * vault's decimals. This also lets the vault-decimals read run in parallel with
+ * this one (no fallback value is needed up front).
+ *
+ * @param provider - EVM contract runner used to read `decimals()`.
+ * @param deposits - Deposit rows from the subgraph; `assetIn` may be absent.
+ * @returns Map of lowercased asset address to decimals (native sentinels and
+ *   successful reads only).
+ */
+async function buildDepositAssetDecimals(provider, deposits) {
+    const map = new Map();
+    // Lowercased native-token sentinels: no ERC-20 `decimals()` exists to read.
+    const nativeSentinels = new Set([
+        ethers_1.ZeroAddress.toLowerCase(),
+        core_1.NATIVE_ADDRESS.toLowerCase(),
+    ]);
+    const unique = new Set();
+    for (const d of deposits ?? []) {
+        if (d?.assetIn)
+            unique.add(d.assetIn.toLowerCase());
+    }
+    await Promise.all([...unique].map(async (addr) => {
+        if (nativeSentinels.has(addr)) {
+            map.set(addr, core_1.EVM_NATIVE_DECIMALS);
+            return;
+        }
+        const dec = await (0, core_1.getDecimals)(provider, addr, false);
+        if (typeof dec === 'number')
+            map.set(addr, dec);
+    }));
+    return map;
+}
+function transformUserHistory(data, chainId, decimals, poolAddress, assetDecimals) {
     //ok to return dupes even though withdraws will return dupe because we parse out duplicate txn hash on the FE
     return [
         ...(data.withdraws?.map((item) => ({
@@ -92,23 +145,33 @@ function transformUserHistory(data, chainId, decimals, poolAddress) {
             timestamp: item.timestamp_,
             decimals: decimals,
         })) || []),
-        ...(data.deposits?.map((item) => ({
-            ...item,
-            contractId_: item.contractId_ || poolAddress,
-            chainId: chainId,
-            type: 'deposit',
-            address: item?.sender || item?.senderAddr,
-            amount: item?.assets || item?.amountIn,
-            transactionHash: item.transactionHash_,
-            timestamp: item.timestamp_,
-            decimals: decimals,
-        })) || []),
+        ...(data.deposits?.map((item) => {
+            // Pair the decimals to the amount's denomination. `assets` (evm-1) is
+            // already in the vault's underlying, so it keeps the vault decimals.
+            // Only `amountIn` (evm-2 / pre-deposit) is denominated in `assetIn`,
+            // which may differ from the vault (e.g. RLUSD 18 → sentUSD 6) and would
+            // otherwise overstate the amount ~1e12×. Using the same source for both
+            // avoids a denomination/decimals mismatch, and the truthy `assetIn`
+            // guard drops empty-string addresses back to the vault decimals.
+            const assetKey = !item?.assets && item.assetIn ? item.assetIn.toLowerCase() : undefined;
+            return {
+                ...item,
+                contractId_: item.contractId_ || poolAddress,
+                chainId: chainId,
+                type: 'deposit',
+                address: item?.sender || item?.senderAddr,
+                amount: item?.assets || item?.amountIn,
+                transactionHash: item.transactionHash_,
+                timestamp: item.timestamp_,
+                decimals: (assetKey ? assetDecimals?.get(assetKey) : undefined) ?? decimals,
+            };
+        }) || []),
     ];
 }
-function sortUserHistory(data, chainId, decimals, poolAddress) {
+function sortUserHistory(data, chainId, decimals, poolAddress, assetDecimals) {
     if (!(data && chainId && decimals))
         return [];
-    return transformUserHistory(data, chainId, decimals, poolAddress).sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_));
+    return transformUserHistory(data, chainId, decimals, poolAddress, assetDecimals).sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_));
 }
 // queries
 const WITHDRAWALS_REQUESTED_QUERY_PROPS = `
@@ -707,9 +770,12 @@ async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = sla
             return requests;
         }
         const json = (await result.json());
-        // Format data
-        const decimals = await (0, core_1.getDecimals)(provider, pool);
-        const formattedRequests = sortUserHistory(json.data, chainId, decimals, pool);
+        // Format data — vault decimals and per-asset decimals are independent reads.
+        const [decimals, assetDecimals] = await Promise.all([
+            (0, core_1.getDecimals)(provider, pool),
+            buildDepositAssetDecimals(provider, json.data?.deposits),
+        ]);
+        const formattedRequests = sortUserHistory(json.data, chainId, decimals, pool, assetDecimals);
         return formattedRequests;
     }
     catch (e) {
@@ -857,10 +923,13 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
                 break;
             skip += PAGE_SIZE;
         }
-        // Format data
+        // Format data — vault decimals and per-asset decimals are independent reads.
         const chainId = await (0, core_1.getChainId)(provider);
-        const decimals = await (0, core_1.getDecimals)(provider, pool);
-        const formattedRequests = sortUserHistory(accumulated, chainId, decimals, pool);
+        const [decimals, assetDecimals] = await Promise.all([
+            (0, core_1.getDecimals)(provider, pool),
+            buildDepositAssetDecimals(provider, accumulated?.deposits),
+        ]);
+        const formattedRequests = sortUserHistory(accumulated, chainId, decimals, pool, assetDecimals);
         return formattedRequests;
     }
     catch (e) {

package/lib/types/api.d.ts

@@ -0,0 +1,280 @@
+import type { IAddress } from './web3';
+/**
+ * A whitelisted token as embedded in loan-book records by the backend
+ * `WhitelistedTokenModel` schema. `chain` is the numeric August chain id
+ * (backend `Chain` IntEnum value, e.g. `1` for Ethereum mainnet).
+ */
+export interface IWhitelistedToken {
+    chain: number;
+    name: string;
+    token_type: string;
+    address: IAddress;
+    decimals: number;
+    symbol: string;
+    discount_factor: number;
+    img_url: string | null;
+    price: number | null;
+}
+/**
+ * The amount and due date of a loan's next scheduled payment, as serialized
+ * by the backend `UpcomingPayment` schema. `due_date` is an ISO-8601 datetime
+ * string.
+ */
+export interface ILoanUpcomingPayment {
+    amount: number;
+    due_date: string;
+}
+/**
+ * One loan-book entry from the admin loan-book endpoints (backend
+ * `LoanBookInfo` schema). Amounts are decimal-adjusted floats; monetary
+ * fields are denominated in the loan's principal token. `deployed_date` is an
+ * ISO-8601 datetime string; `state` is the backend `LoanStateStr` value
+ * (e.g. `"ACTIVE"`).
+ */
+export interface ILoanBookInfo {
+    address: IAddress;
+    lender: IAddress;
+    borrower: IAddress;
+    state: string;
+    total_repaid: number;
+    principal_token: IWhitelistedToken;
+    principal_amount: number;
+    interest_amount: number;
+    upcoming_payment: ILoanUpcomingPayment;
+    apr: number;
+    initial_principal_amount: number;
+    deployed_date: string;
+    payment_interval: number;
+    total_interest_payment_fees: number;
+    lender_apr: number;
+}
+/**
+ * A token's discount-factor ladder from `GET /risk/discount_factors`
+ * (backend `DiscountFactorRead` schema). `steps` are ascending notional
+ * thresholds (in the token's smallest unit) and `factors` the corresponding
+ * ascending haircut multipliers in `[0, 1]`; the two arrays are equal length.
+ * `chain` is the numeric August chain id.
+ */
+export interface IDiscountFactorLadder {
+    steps: number[] | null;
+    factors: number[] | null;
+    address: IAddress;
+    chain: number;
+}
+/**
+ * Result of `GET /risk/collateral_excess_or_deficit` (backend
+ * `CollateralExcessOrDeficit` schema). A positive value is excess collateral
+ * that could be withdrawn; a negative value is the shortfall that must be
+ * deposited to reach the target health factor.
+ */
+export interface ICollateralExcessOrDeficit {
+    amount_usd: number;
+    amount_token: number;
+}
+/**
+ * Request body for `POST /risk/collateral_simulation` (backend
+ * `CollateralSimulation` schema). Chain fields are numeric August chain ids.
+ * `collateral_tokens` is a list of `[chain, address]` pairs and
+ * `collateral_token_allocation` the matching per-token weights (normalized
+ * server-side, so relative magnitudes are what matter). When `on_platform`
+ * is `true`, both `loan_redeployed_token_*` fields are required by the
+ * backend.
+ */
+export interface ICollateralSimulationInput {
+    loan_token_chain: number;
+    loan_token_address: IAddress;
+    loan_amount: number;
+    on_platform?: boolean;
+    loan_redeployed_token_chain?: number | null;
+    loan_redeployed_token_address?: IAddress | null;
+    collateral_tokens: [number, IAddress][];
+    collateral_token_allocation: number[];
+    target_health_factor?: number;
+}
+/**
+ * Per-collateral-token breakdown within a collateral simulation (backend
+ * `CollateralDetailsResult` schema). `chain` is the numeric August chain id.
+ */
+export interface ICollateralDetailsResult {
+    chain: number;
+    token_address: IAddress;
+    price: number;
+    allocation: number;
+    collateral_value_from_redeployed_loan_usd: number;
+    collateral_value_usd: number;
+    amount_usd: number;
+    amount_token: number;
+    effective_discount_factor: number;
+    is_top_up: boolean;
+}
+/**
+ * Result of `POST /risk/collateral_simulation` (backend
+ * `CollateralSimulationResults` schema). `collateral_details` is keyed by
+ * `"<symbol>_<chainName>"`.
+ */
+export interface ICollateralSimulationResults {
+    total_debt_usd: number;
+    total_required_collateral_usd: number;
+    total_collateral_value_from_redeployed_loan_usd: number;
+    health_factor: number;
+    collateral_details: Record<string, ICollateralDetailsResult>;
+}
+/**
+ * Result of the public `GET /revert_reason` endpoint (backend `RevertResponse`
+ * schema) — the decoded failure reasons for a reverted transaction, collected
+ * from a `debug_traceTransaction` call tree. All three arrays are empty when
+ * no matching signal was found in the trace.
+ */
+export interface IRevertReason {
+    error_messages: string[];
+    revert_reasons: string[];
+    universal_subaccount_errors: string[];
+}
+/**
+ * One transaction record from `GET /transactions/v2` (backend
+ * `TransactionAPIRead` schema). `chain` is the numeric August chain id;
+ * `value` is decimal-adjusted; `timestamp` is a Unix epoch (seconds).
+ * `from_` mirrors the backend field name (`from` is reserved). Nested
+ * `logs` / `transfers` / `function_signature` / `otc_cashflow` are passed
+ * through as-is. `transaction_name` is the resolved function name (or the raw
+ * selector when unknown).
+ */
+export interface ISubaccountTransaction {
+    id: string;
+    tx_hash: string;
+    chain: number;
+    from_: IAddress;
+    to: IAddress;
+    value: number;
+    block_number: number;
+    timestamp: number;
+    selector: string | null;
+    logs: unknown[];
+    transfers: unknown[];
+    function_signature: Record<string, unknown> | null;
+    otc_cashflow: Record<string, unknown> | null;
+    transaction_name: string | null;
+}
+/**
+ * DeBank positions and tokens for a single account (backend
+ * `DebankAccountData` schema). `positions`, `app_positions`, and `tokens`
+ * are passed through as raw DeBank objects.
+ */
+export interface ISubaccountDebankData {
+    positions: unknown[];
+    app_positions: unknown[];
+    tokens: unknown[];
+}
+/**
+ * Cross-chain DeBank protocol positions for a subaccount and its associated
+ * strategies (backend `SubaccountDebankAccountData` schema). `strategies` is
+ * keyed by strategy address. This endpoint is slow (300-second server-side
+ * cache) as it fans out across every supported chain.
+ */
+export interface ISubaccountDebank {
+    subaccount: ISubaccountDebankData;
+    strategies: Record<string, ISubaccountDebankData>;
+}
+/**
+ * A tracked position from `GET /otc/position` (backend `IPositionRead`
+ * schema). `configs` is a free-form JSON object of position-specific
+ * settings; `category` is the position category (e.g. `"otc"`).
+ */
+export interface IOtcPositionRead {
+    id: string;
+    slug: string;
+    position_class: string | null;
+    configs: Record<string, unknown> | null;
+    category: string | null;
+    position_discount_factor: number | null;
+}
+/**
+ * An OTC margin requirement from `GET /otc/margin_requirement` (backend
+ * `IOTCMarginRequirementRead` schema) — the margin the `payer` must post to
+ * the given counterparty.
+ */
+export interface IOtcMarginRequirement {
+    otc_counter_party_id: string;
+    margin_requirement: number;
+    payer: IAddress;
+}
+/**
+ * On-chain whitelist status of one subaccount linked to a vault, from
+ * `GET /curator/vaults/{vault_address}/whitelist` (backend
+ * `WhitelistStatusResponse` schema). EVM vaults only.
+ */
+export interface ICuratorWhitelistStatus {
+    address: IAddress;
+    is_whitelisted: boolean;
+}
+/**
+ * One timelock request from `GET /timelock-requests` (backend
+ * `ITimelockRequestRead` schema). `chain_id` is the numeric chain id;
+ * `status` is one of `"scheduled" | "executed" | "cancelled"`; `params` is a
+ * free-form JSON object; datetime fields are ISO-8601 strings.
+ */
+export interface ITimelockRequest {
+    id: string;
+    hash: string;
+    vault_address: IAddress;
+    timelock_address: IAddress;
+    chain_id: number;
+    action_id: string;
+    params: Record<string, unknown>;
+    status: string;
+    schedule_tx_hash: string;
+    execute_tx_hash: string | null;
+    cancel_tx_hash: string | null;
+    submitted_by: string | null;
+    scheduled_at: string;
+    resolved_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+/**
+ * Performance-fee computation for a vault from
+ * `GET /metrics/vault_performance_fees` (backend `UpshiftVaultPerformanceFees`
+ * schema). High/low water marks are share-price levels; `*_datetime` fields
+ * are ISO-8601 strings. `calculation_period` is `"YearToDate"` /
+ * `"MonthToDate"` (null when a custom date range was supplied).
+ */
+export interface IVaultPerformanceFees {
+    previous_water_mark: number;
+    previous_water_mark_datetime: string;
+    last_water_mark: number;
+    last_water_mark_datetime: string;
+    is_in_drawdown: boolean;
+    asset_symbol: string | null;
+    total_pnl_in_asset: number;
+    total_perf_fees_asset: number;
+    calculation_period: string | null;
+    annualized_fees_pct: number;
+    underlying_asset_vs_native_perf: number | null;
+    native_token_symbol: string | null;
+}
+/**
+ * One row of a vault's NAV-oracle classification table (backend
+ * `OracleClassificationRow` schema) — how a single position/token is priced
+ * and its USD value.
+ */
+export interface IOracleClassificationRow {
+    position: string;
+    type: string;
+    oracle_source: string;
+    usd_value: number;
+}
+/**
+ * A vault's NAV-oracle classification from the public
+ * `GET /upshift/oracle_classification/{vault_address}` endpoint (backend
+ * `OracleClassificationResponse` schema). `warnings` lists tokens that could
+ * not be resolved (`"unresolved:<symbol>"`). `snapshot_at` is an ISO-8601
+ * datetime string.
+ */
+export interface IOracleClassification {
+    vault_address: IAddress;
+    chain_id: number;
+    snapshot_at: string;
+    methodology: string;
+    rows: IOracleClassificationRow[];
+    warnings: string[];
+}

package/lib/types/api.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

package/lib/types/index.d.ts

@@ -9,3 +9,4 @@ export * from './subgraph';
 export * from './vaults';
 export * from './points';
 export * from './sub-accounts';
+export * from './api';

package/lib/types/index.js

@@ -24,4 +24,5 @@ __exportStar(require("./subgraph"), exports);
 __exportStar(require("./vaults"), exports);
 __exportStar(require("./points"), exports);
 __exportStar(require("./sub-accounts"), exports);
+__exportStar(require("./api"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/sub-accounts.d.ts

@@ -1,4 +1,40 @@
 import type { IAddress } from './web3';
+/**
+ * Chain record attached to a subaccount directory entry, as serialized by the
+ * backend `IChainRead` schema.
+ */
+export interface IWSSubaccountListChain {
+    id: string;
+    chain_id: number;
+    name: string;
+}
+/**
+ * One subaccount record from the admin-only `GET /subaccount` directory
+ * endpoint (backend `ISubaccountRead` schema). Nullable fields are optional
+ * metadata the operations team may not have filled in.
+ */
+export interface IWSSubaccountListItem {
+    id: string;
+    user_id: string | null;
+    internal_name: string;
+    friendly_name: string | null;
+    address: IAddress;
+    status: string | null;
+    subaccount_type: string | null;
+    min_health_factor: number | null;
+    estimated_apr: number | null;
+    notes: string | null;
+    proxy_salt: string | null;
+    admin_salt: string | null;
+    disable_discount_factor: boolean | null;
+    turnkey_address: IAddress | null;
+    autopay_frequency: string | null;
+    implementation: string | null;
+    variant: string | null;
+    default_fee_rate_in_bips: number | null;
+    wallet_role: string | null;
+    chains: IWSSubaccountListChain[];
+}
 export interface IWSSubAccountHealthFactor {
     id: IAddress;
     datetime: string;

package/lib/types/subgraph.d.ts

@@ -35,6 +35,14 @@ export interface ISubgraphDeposit extends ISubgraphBase {
     owner: IAddress;
     senderAddr?: IAddress;
     amountIn?: string;
+    /**
+     * Deposit asset token address (evm-2 / pre-deposit vaults). The deposited
+     * asset can differ from the vault's underlying and carry different decimals
+     * (e.g. RLUSD at 18 into a 6-decimal sentUSD vault), so `amountIn` must be
+     * normalized against this token's decimals, not the vault's. Absent for
+     * single-asset vaults.
+     */
+    assetIn?: IAddress;
 }
 export interface ISubgraphWithdrawRequest extends ISubgraphBase {
     day: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "8.7.2",
+  "version": "8.9.0",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [