@augustdigital/sdk 9.0.0 → 9.2.0

package/lib/services/untangled/utils.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNTANGLED_PROTOCOL_REGISTRY = void 0;
+exports.transformUntangledToDebank = transformUntangledToDebank;
+/**
+ * Display metadata for the protocol slugs Untangled reports today.
+ *
+ * Untangled does not return protocol names or chains, so they are mapped here.
+ * Unknown slugs fall back to a capitalized slug on the vault's chain rather than
+ * being dropped, so a newly integrated protocol still shows up (unlabelled)
+ * instead of silently vanishing from the breakdown.
+ */
+exports.UNTANGLED_PROTOCOL_REGISTRY = {
+    blend: { name: 'Blend', chain: 'stellar' },
+    templar: { name: 'Templar (NEAR)', chain: 'near' },
+    aquarius: { name: 'Aquarius', chain: 'stellar' },
+};
+/**
+ * Slugs that are not protocol positions: `stellar-wallet` is custody wallet
+ * cash and `upshift` is the vault's own idle buffer. Both are undeployed
+ * capital, which the exposure breakdown renders as wallet holdings — the same
+ * treatment EVM vaults get for funds sitting outside a protocol.
+ */
+const WALLET_PROTOCOL_IDS = new Set(['stellar-wallet', 'upshift']);
+const DEFAULT_CHAIN = 'stellar';
+/**
+ * Stellar's asset precision, carried only to satisfy the DeBank token shape.
+ * The synthesized tokens hold USD values (`price: 1`), so no consumer scales by
+ * this.
+ */
+const SYNTHETIC_TOKEN_DECIMALS = 7;
+/**
+ * Build a DeBank-shaped token carrying a USD value.
+ *
+ * `parseVaultLevelDebank` computes USD as `price * amount`, so a value already
+ * denominated in dollars is expressed as `price: 1, amount: <usd>`.
+ */
+function toDebankToken(symbol, chain, valueUsd, exposureType, protocolId) {
+    return {
+        id: symbol,
+        chain,
+        name: symbol,
+        symbol,
+        optimized_symbol: symbol,
+        decimals: SYNTHETIC_TOKEN_DECIMALS,
+        logo_url: '',
+        amount: valueUsd,
+        price: 1,
+        protocol_id: protocolId ?? '',
+        supplying_exposure: exposureType === 'supply' ? 'true' : undefined,
+    };
+}
+/**
+ * The asset holding most of the vault's value.
+ *
+ * Untangled splits assets vault-wide rather than per protocol, so every
+ * synthesized position is tagged with this one symbol. For the Gami vaults it is
+ * an exact description (earnUSDC is ~100% USDC); an exact per-protocol split
+ * needs `byProtocol[].assets[]` from Untangled.
+ */
+function dominantAssetSymbol(exposure) {
+    const dominant = (exposure.byAsset || []).reduce((best, asset) => !best || Number(asset?.valueUsd || 0) > Number(best.valueUsd || 0)
+        ? asset
+        : best, null);
+    return dominant?.symbol || 'UNKNOWN';
+}
+/**
+ * Transform an Untangled vault exposure report into the DeBank-normalized shape
+ * that `parseVaultLevelDebank` and `parseLoanLevelDebank` consume.
+ *
+ * This is the Stellar equivalent of `transformOctavfiToDebank`: a foreign
+ * portfolio shape is mapped onto the one normalized structure the vault
+ * allocation parser understands, so Stellar vaults populate the same
+ * `exposurePerCategory` / `protocolExposure` / `tokenExposure` outputs as EVM
+ * vaults with no parser changes.
+ *
+ * Mapping:
+ * - Each `byProtocol` entry becomes one position with a single supplying token,
+ *   valued in USD (`price: 1`), on the chain from
+ *   {@link UNTANGLED_PROTOCOL_REGISTRY}.
+ * - `stellar-wallet` and `upshift` are summed into one wallet token, because
+ *   both are undeployed capital rather than protocol exposure.
+ * - Dust is left in place: `filterOutBySize` in the parser applies the same
+ *   threshold Stellar and EVM vaults share.
+ *
+ * `locations`, `asOf`, `stale` and `tvlUsd` are not consumed — TVL already comes
+ * from `getVaultTvl`, and freshness is not yet surfaced on `IVaultAllocations`.
+ *
+ * @param exposure - A resolved Untangled report, or `null`/`undefined` when the
+ *   fetch failed.
+ * @returns A DeBank-normalized response. Empty positions and tokens when
+ *   `exposure` is absent, so callers can pass a failed fetch straight through.
+ *
+ * @example
+ * ```typescript
+ * const exposure = await fetchUntangledVaultExposure(vault);
+ * const normalized = transformUntangledToDebank(exposure);
+ * parseVaultLevelDebank(
+ *   normalized, protocolExposure, tokenExposure, vault, exposurePerCategory, netValue,
+ * );
+ * ```
+ */
+function transformUntangledToDebank(exposure) {
+    if (!exposure) {
+        return { subaccount: { positions: [], tokens: [] } };
+    }
+    const symbol = dominantAssetSymbol(exposure);
+    const vaultChain = exposure.vault?.chain || DEFAULT_CHAIN;
+    const positions = [];
+    let walletValueUsd = 0;
+    (exposure.byProtocol || []).forEach((entry) => {
+        if (!entry?.protocolId)
+            return;
+        const valueUsd = Number(entry.valueUsd) || 0;
+        if (WALLET_PROTOCOL_IDS.has(entry.protocolId)) {
+            walletValueUsd += valueUsd;
+            return;
+        }
+        const metadata = exports.UNTANGLED_PROTOCOL_REGISTRY[entry.protocolId];
+        const chain = metadata?.chain || vaultChain;
+        const name = metadata?.name ||
+            entry.protocolId.charAt(0).toUpperCase() + entry.protocolId.slice(1);
+        positions.push({
+            id: entry.protocolId,
+            chain,
+            name,
+            logo_url: '',
+            site_url: '',
+            portfolio_item_list: [
+                {
+                    name,
+                    stats: {
+                        asset_usd_value: valueUsd,
+                        debt_usd_value: 0,
+                        net_usd_value: valueUsd,
+                    },
+                    detail: {
+                        supply_token_list: [
+                            toDebankToken(symbol, chain, valueUsd, 'supply', entry.protocolId),
+                        ],
+                        borrow_token_list: [],
+                    },
+                },
+            ],
+        });
+    });
+    const tokens = [];
+    if (walletValueUsd > 0) {
+        tokens.push({
+            ...toDebankToken(symbol, vaultChain, walletValueUsd, 'wallet'),
+            is_wallet: true,
+            is_core: true,
+        });
+    }
+    return { subaccount: { positions, tokens } };
+}
+//# sourceMappingURL=utils.js.map

package/package.json

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