@augustdigital/sdk 8.3.2 → 8.5.0

package/lib/services/coingecko/fetcher.d.ts

@@ -1 +1,14 @@
+/**
+ * Fetch the latest USD price for a token symbol from CoinGecko's
+ * `/market_chart/range` endpoint, mapped through `COINGECKO_COIN_ID_MAP`.
+ *
+ * @param symbol Token symbol (case-insensitive). Must be present in
+ *   `COINGECKO_COIN_ID_MAP`; unmapped symbols still hit the network and
+ *   404 today (see todo/32-coingecko-fetcher-defects.md).
+ * @param coinGeckoKey CoinGecko Pro API key passed as `x-cg-pro-api-key`.
+ * @returns The latest price in USD on success; `null` on any failure
+ *   (non-2xx response, network error, JSON parse error, or missing
+ *   `prices` array). The `musd` short-circuit returns a tuple literal
+ *   for back-compat — see todo/32 for the cleanup.
+ */
 export declare function fetchTokenPricesFromCoinGecko(symbol: string, coinGeckoKey: string): Promise<any>;

package/lib/services/coingecko/fetcher.js

@@ -3,11 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchTokenPricesFromCoinGecko = fetchTokenPricesFromCoinGecko;
 const logger_1 = require("../../core/logger");
 const utils_1 = require("./utils");
+/**
+ * Fetch the latest USD price for a token symbol from CoinGecko's
+ * `/market_chart/range` endpoint, mapped through `COINGECKO_COIN_ID_MAP`.
+ *
+ * @param symbol Token symbol (case-insensitive). Must be present in
+ *   `COINGECKO_COIN_ID_MAP`; unmapped symbols still hit the network and
+ *   404 today (see todo/32-coingecko-fetcher-defects.md).
+ * @param coinGeckoKey CoinGecko Pro API key passed as `x-cg-pro-api-key`.
+ * @returns The latest price in USD on success; `null` on any failure
+ *   (non-2xx response, network error, JSON parse error, or missing
+ *   `prices` array). The `musd` short-circuit returns a tuple literal
+ *   for back-compat — see todo/32 for the cleanup.
+ */
 async function fetchTokenPricesFromCoinGecko(symbol, coinGeckoKey) {
     const coinId = utils_1.COINGECKO_COIN_ID_MAP[symbol.toLowerCase()];
     if (coinId === 'mezo-usd') {
         return [['175394880000', 1]];
     }
+    // this is what we do in FE - not sure if we really need 7d worth of data since we just want something but it'll do for now
     const sevendDaysInS = 7 * 24 * 60 * 60;
     const from = Date.now() / 1000 - sevendDaysInS;
     const url = `https://pro-api.coingecko.com/api/v3/coins/${coinId}/market_chart/range?vs_currency=usd&from=${from}&to=${Math.floor(Date.now() / 1000)}&interval=daily`;
@@ -30,6 +44,9 @@ async function fetchTokenPricesFromCoinGecko(symbol, coinGeckoKey) {
             throw err;
         }
         const data = (await response.json());
+        // `/market_chart/range` returns `{ prices, market_caps, total_volumes }` —
+        // an object. The previous `data.length` check was always falsy on the
+        // success path and silently collapsed every valid response to `null`.
         if (data?.prices?.length) {
             return data.prices[data.prices.length - 1][1];
         }

package/lib/services/debank/fetcher.d.ts

@@ -107,6 +107,20 @@ export interface IDebankAccountData {
 export interface IDebankAccountDataError {
     error: string;
 }
+/**
+ * Response type for vault-level DeBank data.
+ * Keys are subaccount addresses, values are either DeBank data or error objects.
+ */
 export type IVaultDebankResponse = Record<string, IDebankAccountData | IDebankAccountDataError>;
+/**
+ * Fetch DeBank data for all subaccounts of a vault in a single request.
+ * @param vaultAddress The vault contract address
+ * @param headers Optional monitoring headers
+ * @returns Dictionary of subaccount addresses to DeBank data, or false on error
+ */
 export declare function fetchVaultDebankResponse(vaultAddress: IAddress, headers?: IWSMonitorHeaders): Promise<IVaultDebankResponse | false>;
+/**
+ * @deprecated Use fetchVaultDebankResponse for vault-level queries.
+ * Fetch DeBank data for a single subaccount address.
+ */
 export declare function fetchDebankResponse(address: IAddress, headers?: IWSMonitorHeaders): Promise<any>;

package/lib/services/debank/fetcher.js

@@ -3,9 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchVaultDebankResponse = fetchVaultDebankResponse;
 exports.fetchDebankResponse = fetchDebankResponse;
 const core_1 = require("../../core");
+/**
+ * Fetch DeBank data for all subaccounts of a vault in a single request.
+ * @param vaultAddress The vault contract address
+ * @param headers Optional monitoring headers
+ * @returns Dictionary of subaccount addresses to DeBank data, or false on error
+ */
 async function fetchVaultDebankResponse(vaultAddress, headers) {
     try {
         const response = await (0, core_1.fetchAugustPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.debank(vaultAddress), { headers: headers });
+        // 200 = success, 207 = partial success (some subaccounts failed)
         if (response.status === 200 || response.status === 207) {
             const data = (await response.json());
             return data;
@@ -18,7 +25,12 @@ async function fetchVaultDebankResponse(vaultAddress, headers) {
         return false;
     }
 }
+/**
+ * @deprecated Use fetchVaultDebankResponse for vault-level queries.
+ * Fetch DeBank data for a single subaccount address.
+ */
 async function fetchDebankResponse(address, headers) {
+    // filter out hyperevm since debank does not yet support hyperevm
     const debankResponse = await (0, core_1.fetchAugustWithKey)(undefined, core_1.WEBSERVER_ENDPOINTS.subaccount.debank(address), { override: true, headers: headers });
     if (debankResponse.status !== 200) {
         core_1.Logger.log.error('fetchDebankResponse', new Error(`HTTP ${debankResponse.status} ${debankResponse.statusText}`), {

package/lib/services/debank/utils.js

@@ -47,12 +47,14 @@ function addToTokenExposure(token, tokenExposure, exposureType, protocol, exposu
     }
 }
 function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borrower, exposurePerCategory, netValue) {
+    // new mapping to grab vault-level token and protocol exposure per
     const tokenMap = {};
     const protocolTokenMap = {};
     const protocolExposures = debankRes?.subaccount?.positions || [];
     const appProtocolExposures = debankRes?.subaccount?.app_positions || [];
     const tokenExposures = debankRes?.subaccount?.tokens || [];
     protocolExposures.forEach((pos) => {
+        // protocol-level data fetching
         const protoReturnObj = {
             id: pos?.id,
             chain: pos?.chain,
@@ -68,6 +70,7 @@ function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borro
             address: borrower,
         };
         pos?.portfolio_item_list?.forEach((item) => {
+            // initialize protocol exposure
             protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
             protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
             protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
@@ -83,21 +86,27 @@ function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borro
             foundExistingProtocolExposure.assetUsdValue +=
                 protoReturnObj.assetUsdValue;
         }
+        // go through the debank portfolio
         pos.portfolio_item_list.forEach((item) => {
             item.detail.supply_token_list.forEach((sup) => {
+                // add protocol id for vault-level "protocol exposure"
                 if (sup?.protocol_id) {
                     const existingArray = protocolTokenMap[sup.protocol_id] || [];
                     if (!existingArray.includes(sup.symbol))
                         existingArray.push(sup.symbol);
                 }
+                // add token to vault "token exposure"
                 addToTokenExposure(sup, tokenExposure, 'supply', pos.id, exposurePerCategory, netValue, borrower);
+                // add token image url to token mapping for display
                 if (sup?.symbol && sup?.logo_url) {
                     tokenMap[sup.symbol] = sup.logo_url;
                 }
                 tokenMap[sup.supplying_exposure] = 'true';
             });
             item.detail.borrow_token_list.forEach((bor) => {
+                // add token to vault "token exposure"
                 addToTokenExposure(bor, tokenExposure, 'borrow', pos.id, exposurePerCategory, netValue, borrower);
+                // add token image url to token mapping for display
                 if (bor?.symbol && bor?.logo_url) {
                     tokenMap[bor.symbol] = bor.logo_url;
                 }
@@ -105,6 +114,8 @@ function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borro
             });
         });
     });
+    // Process non-EVM app protocols (e.g. Hyperliquid, Lighter).
+    // These lack chain and protocol_id fields unlike EVM-based positions.
     appProtocolExposures.forEach((pos) => {
         const protoReturnObj = {
             id: pos?.id,
@@ -202,6 +213,8 @@ function getVaultExposure(debankResponse) {
                     !token.is_suspicious &&
                     !token.is_scam &&
                     token?.is_core) {
+                    // Not sure what isWallet is, but I'm guessing is that this field means that it should be in wallet exposure...
+                    // fwiw I have seen this double counted in supplyTokens AND tokens
                     if (!token.is_wallet) {
                         supplying_exposure.push({
                             symbol: token.symbol,
@@ -219,10 +232,12 @@ function parseLoanLevelDebank(debankRes) {
     let positions = [];
     let exposure = [];
     try {
+        // new mapping to grab token and protocol exposure
         const protocolExposures = [
             ...(debankRes?.subaccount?.positions || []),
             ...(debankRes?.subaccount?.app_positions || []),
         ];
+        // Old mapping to grab token and protocol exposure
         positions = protocolExposures?.map((p) => ({
             value: p.logo_url,
             label: p.name,
@@ -243,6 +258,8 @@ function parseLoanLevelDebank(debankRes) {
             }
             return extra;
         }));
+        // this is a request where if there is no protocol exposure then show any spots
+        // over 10k in collateral exposure
         if (protocolExposures.length === 0) {
             if (debankRes?.subaccount?.tokens) {
                 debankRes.subaccount.tokens.forEach((t) => {

package/lib/services/layerzero/deposits.d.ts

@@ -1,3 +1,7 @@
+/**
+ * LayerZero Deposits Service
+ * Handles querying LayerZero USDC deposits from subgraphs
+ */
 import { IAddress } from '../../types';
 export declare const LAYERZERO_VAULTS: {
     coreUSDC: {
@@ -34,5 +38,12 @@ export interface ILayerZeroDeposit {
     transactionHash_: string;
     timestamp_: string;
 }
+/**
+ * Check if a vault address or symbol is a LayerZero vault
+ */
 export declare function isLayerZeroVault(vaultAddressOrSymbol: string): keyof typeof LAYERZERO_VAULTS | null;
+/**
+ * Query LayerZero deposits from the appropriate subgraph
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
 export declare function queryLayerZeroDeposits(vaultKey: keyof typeof LAYERZERO_VAULTS, wallet?: IAddress): Promise<ILayerZeroDeposit[]>;

package/lib/services/layerzero/deposits.js

@@ -1,21 +1,27 @@
 "use strict";
+/**
+ * LayerZero Deposits Service
+ * Handles querying LayerZero USDC deposits from subgraphs
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LAYERZERO_VAULTS = void 0;
 exports.isLayerZeroVault = isLayerZeroVault;
 exports.queryLayerZeroDeposits = queryLayerZeroDeposits;
 const fetcher_1 = require("../subgraph/fetcher");
 const utils_1 = require("./utils");
+// LayerZero vault addresses and their corresponding receipt tokens
+// spokeChains maps chainId -> shareOFT address (receipt token on that chain)
 exports.LAYERZERO_VAULTS = {
     coreUSDC: {
         address: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
         receiptToken: 'coreusdc',
-        decimals: 6,
+        decimals: 6, // USDC decimals
         hubChainId: 1,
         spokeChains: {
-            42161: '0x50a31ff4d57841681011837c17aa201c6a34203c',
-            43114: '0x1FA931Bf85248aD2eDf0004DD9A284698358e708',
-            8453: '0x1fa931bf85248ad2edf0004dd9a284698358e708',
-            146: '0x4bdd224fe59a3ae0b249125ad4c5b3126074c71b',
+            42161: '0x50a31ff4d57841681011837c17aa201c6a34203c', // Arbitrum
+            43114: '0x1FA931Bf85248aD2eDf0004DD9A284698358e708', // Avalanche
+            8453: '0x1fa931bf85248ad2edf0004dd9a284698358e708', // Base
+            146: '0x4bdd224fe59a3ae0b249125ad4c5b3126074c71b', // Sonic
         },
         subgraphEndpoints: [
             'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-coreusdc/1.0.0/gn',
@@ -24,13 +30,13 @@ exports.LAYERZERO_VAULTS = {
     upUSDC: {
         address: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
         receiptToken: 'upusdc',
-        decimals: 6,
+        decimals: 6, // USDC decimals
         hubChainId: 1,
         spokeChains: {
-            42161: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34',
-            43114: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34',
-            8453: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34',
-            146: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34',
+            42161: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Arbitrum
+            43114: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34', // Avalanche
+            8453: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Base
+            146: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Sonic
         },
         subgraphEndpoints: [
             'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-upusdc/1.0.0/gn',
@@ -42,7 +48,7 @@ exports.LAYERZERO_VAULTS = {
         decimals: 6,
         hubChainId: 143,
         spokeChains: {
-            1: '0xa6916b65c5e3fEdf46c0a2F59bff776e872C8992',
+            1: '0xa6916b65c5e3fEdf46c0a2F59bff776e872C8992', // Ethereum
         },
         subgraphEndpoints: [
             'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-earnAUSD/1.0.0/gn',
@@ -50,8 +56,12 @@ exports.LAYERZERO_VAULTS = {
         ],
     },
 };
+/**
+ * Check if a vault address or symbol is a LayerZero vault
+ */
 function isLayerZeroVault(vaultAddressOrSymbol) {
     const normalized = vaultAddressOrSymbol.toLowerCase();
+    // Check by address
     if (normalized === exports.LAYERZERO_VAULTS.coreUSDC.address.toLowerCase() ||
         normalized === 'coreusdc') {
         return 'coreUSDC';
@@ -66,6 +76,9 @@ function isLayerZeroVault(vaultAddressOrSymbol) {
     }
     return null;
 }
+/**
+ * Validate GraphQL response structure
+ */
 function validateDepositResponse(result) {
     if (!result || typeof result !== 'object') {
         return false;
@@ -80,8 +93,13 @@ function validateDepositResponse(result) {
     }
     return true;
 }
+/**
+ * Query LayerZero deposits from the appropriate subgraph
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
 async function queryLayerZeroDeposits(vaultKey, wallet) {
     const vaultConfig = exports.LAYERZERO_VAULTS[vaultKey];
+    // Build GraphQL query (fetchSubgraph prepends "query " automatically)
     let query = `GetDeposits {
       depositeds(first: 1000) {
         assetAmt
@@ -93,6 +111,7 @@ async function queryLayerZeroDeposits(vaultKey, wallet) {
         timestamp_
       }
     }`;
+    // If wallet is provided, filter by sender
     if (wallet) {
         const senderBytes32 = (0, utils_1.addressToBytes32)(wallet);
         query = `GetDeposits {
@@ -112,6 +131,7 @@ async function queryLayerZeroDeposits(vaultKey, wallet) {
     for (let i = 0; i < endpoints.length; i++) {
         try {
             const response = await (0, fetcher_1.fetchSubgraph)(endpoints[i], query);
+            // Only fall through to next endpoint on 404 (wrong URL casing)
             if (response.status === 404 && i < endpoints.length - 1) {
                 continue;
             }
@@ -122,6 +142,7 @@ async function queryLayerZeroDeposits(vaultKey, wallet) {
             if (result.errors) {
                 throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
             }
+            // Validate response structure
             if (!validateDepositResponse(result)) {
                 throw new Error(`Invalid response structure from LayerZero subgraph. Expected data.depositeds array, got: ${JSON.stringify(result)}`);
             }
@@ -129,10 +150,12 @@ async function queryLayerZeroDeposits(vaultKey, wallet) {
         }
         catch (error) {
             lastError = error;
+            // Only continue to next endpoint on network-level failures; re-throw application errors immediately
             if (i >= endpoints.length - 1)
                 break;
         }
     }
+    // All endpoints failed — throw the last error with context
     if (lastError instanceof Error) {
         const enhancedError = new Error(`Failed to fetch LayerZero deposits for ${vaultKey}: ${lastError.message}`);
         enhancedError.stack = lastError.stack;

package/lib/services/layerzero/redeems.d.ts

@@ -1,3 +1,7 @@
+/**
+ * LayerZero Redeems Service
+ * Handles querying LayerZero earnAUSD redeems from subgraphs
+ */
 import { IAddress } from '../../types';
 export interface ILayerZeroRedeem {
     id: string;
@@ -7,4 +11,10 @@ export interface ILayerZeroRedeem {
     transactionHash_: string;
     timestamp_: string;
 }
+/**
+ * Query LayerZero redeems for earnAUSD from the subgraph.
+ * Uses the same earnAUSD subgraph endpoints as deposits — the subgraph indexes
+ * both Deposited and Redeemed events from the same contract.
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
 export declare function queryLayerZeroRedeems(wallet?: IAddress): Promise<ILayerZeroRedeem[]>;

package/lib/services/layerzero/redeems.js

@@ -1,9 +1,16 @@
 "use strict";
+/**
+ * LayerZero Redeems Service
+ * Handles querying LayerZero earnAUSD redeems from subgraphs
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryLayerZeroRedeems = queryLayerZeroRedeems;
 const fetcher_1 = require("../subgraph/fetcher");
 const deposits_1 = require("./deposits");
 const utils_1 = require("./utils");
+/**
+ * Validate GraphQL response structure for redeems
+ */
 function validateRedeemResponse(result) {
     if (!result || typeof result !== 'object') {
         return false;
@@ -18,6 +25,12 @@ function validateRedeemResponse(result) {
     }
     return true;
 }
+/**
+ * Query LayerZero redeems for earnAUSD from the subgraph.
+ * Uses the same earnAUSD subgraph endpoints as deposits — the subgraph indexes
+ * both Deposited and Redeemed events from the same contract.
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
 async function queryLayerZeroRedeems(wallet) {
     const vaultConfig = deposits_1.LAYERZERO_VAULTS.earnAUSD;
     let query = `GetRedeems {

package/lib/services/layerzero/utils.d.ts

@@ -1 +1,9 @@
+/**
+ * Shared LayerZero utilities
+ */
+/**
+ * Convert Ethereum address to bytes32 format (left-padded with zeros)
+ * Used by LayerZero subgraph queries where addresses are stored in bytes32 format.
+ * @throws {Error} If address format is invalid
+ */
 export declare function addressToBytes32(address: string): string;

package/lib/services/layerzero/utils.js

@@ -1,11 +1,22 @@
 "use strict";
+/**
+ * Shared LayerZero utilities
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addressToBytes32 = addressToBytes32;
+/**
+ * Convert Ethereum address to bytes32 format (left-padded with zeros)
+ * Used by LayerZero subgraph queries where addresses are stored in bytes32 format.
+ * @throws {Error} If address format is invalid
+ */
 function addressToBytes32(address) {
+    // Validate address format
     if (!address.match(/^0x[a-fA-F0-9]{40}$/)) {
         throw new Error(`Invalid Ethereum address format: ${address}. Expected format: 0x followed by 40 hexadecimal characters.`);
     }
+    // Remove 0x prefix and convert to lowercase
     const cleanAddress = address.replace(/^0x/i, '').toLowerCase();
+    // Pad with 24 zeros (12 bytes) to make it 32 bytes total
     return '0x' + '0'.repeat(24) + cleanAddress;
 }
 //# sourceMappingURL=utils.js.map

package/lib/services/octavfi/fetcher.d.ts

@@ -1,2 +1,9 @@
 import { IOctavfiPortfolio } from './types';
+/**
+ * Fetches portfolio data from Octavfi API.
+ * Note: The API currently doesn't support multiple addresses in a single request,
+ * so individual requests are made for each address.
+ * @param addresses - Array of addresses to fetch data for.
+ * @returns Array of portfolio data (may be empty if all requests fail).
+ */
 export declare function fetchOctavfiPortfolios(addresses: string[]): Promise<IOctavfiPortfolio[]>;

package/lib/services/octavfi/fetcher.js

@@ -6,6 +6,13 @@ const utils_1 = require("../../adapters/solana/utils");
 const core_1 = require("../../core");
 const BASE_URL = 'https://api.octav.fi';
 const OCTAVFI_API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwczovL2hhc3VyYS5pby9qd3QvY2xhaW1zIjp7IngtaGFzdXJhLWRlZmF1bHQtcm9sZSI6InVzZXIiLCJ4LWhhc3VyYS1hbGxvd2VkLXJvbGVzIjpbInVzZXIiXSwieC1oYXN1cmEtdXNlci1pZCI6ImF1Z3VzdDEyMjM0In19.zaMUtrtdC82uaDh6XSZrsneEcKO3PFOE6FyX3G-MR6c';
+/**
+ * Filters addresses to only include EVM and Solana wallet addresses.
+ * Excludes Sui addresses and other non-supported address formats.
+ *
+ * @param addresses - Array of addresses to filter
+ * @returns Array containing only EVM and Solana addresses
+ */
 function filterEvmAndSolanaAddresses(addresses) {
     return addresses.filter((address) => {
         if (!address || typeof address !== 'string')
@@ -20,6 +27,11 @@ function filterEvmAndSolanaAddresses(addresses) {
         return false;
     });
 }
+/**
+ * Fetches portfolio data for a single address from Octavfi API.
+ * @param address - Single address to fetch data for.
+ * @returns Portfolio data or null if request fails.
+ */
 async function fetchSinglePortfolio(address) {
     try {
         const response = await fetch(`${BASE_URL}/v1/portfolio?addresses=${address}`, {
@@ -47,18 +59,22 @@ async function fetchSinglePortfolio(address) {
             core_1.Logger.log.error('fetchSinglePortfolio.api-error', new Error(String(data.error)), { address });
             return null;
         }
+        // Handle nested array response: [[portfolio]] or [portfolio] or portfolio
         let portfolio = data;
         if (Array.isArray(data)) {
             if (data.length > 0 && Array.isArray(data[0])) {
+                // Nested array: [[portfolio]]
                 portfolio = data[0][0];
             }
             else if (data.length > 0) {
+                // Single array: [portfolio]
                 portfolio = data[0];
             }
             else {
                 return null;
             }
         }
+        // Return raw Octavfi data (transformation should happen separately when needed)
         return portfolio;
     }
     catch (error) {
@@ -66,13 +82,22 @@ async function fetchSinglePortfolio(address) {
         return null;
     }
 }
+/**
+ * Fetches portfolio data from Octavfi API.
+ * Note: The API currently doesn't support multiple addresses in a single request,
+ * so individual requests are made for each address.
+ * @param addresses - Array of addresses to fetch data for.
+ * @returns Array of portfolio data (may be empty if all requests fail).
+ */
 async function fetchOctavfiPortfolios(addresses) {
     const filteredAddresses = filterEvmAndSolanaAddresses(addresses);
     if (filteredAddresses.length === 0) {
         return [];
     }
+    // Fetch portfolios for each address in parallel
     const portfolioPromises = filteredAddresses.map((address) => fetchSinglePortfolio(address));
     const portfolios = await Promise.all(portfolioPromises);
+    // Filter out null results (failed requests)
     return portfolios.filter((portfolio) => portfolio !== null);
 }
 //# sourceMappingURL=fetcher.js.map

package/lib/services/octavfi/utils.d.ts

@@ -1,4 +1,16 @@
 import { IOctavfiPortfolio } from './types';
 import { IDebankNormalizedResponse } from '../debank/utils';
+/**
+ * Transforms Octavfi portfolio response to DeBank-compatible format.
+ * This allows Solana addresses to use Octavfi data while maintaining
+ * compatibility with existing DeBank parsing functions.
+ *
+ * @param octavfiPortfolio - Octavfi portfolio response
+ * @returns DeBank-compatible response structure
+ */
 export declare function transformOctavfiToDebank(octavfiPortfolio: IOctavfiPortfolio | null | undefined): IDebankNormalizedResponse;
+/**
+ * Transforms multiple Octavfi portfolios to DeBank format.
+ * Used when fetching multiple addresses.
+ */
 export declare function transformOctavfiPortfoliosToDebank(portfolios: IOctavfiPortfolio[]): any[];