@augustdigital/sdk 8.3.2 → 8.5.0

package/lib/core/helpers/chain-address.js

@@ -5,7 +5,12 @@ exports.isStellarAddress = isStellarAddress;
 exports.isSuiAddress = isSuiAddress;
 const ethers_1 = require("ethers");
 const web3_js_1 = require("@solana/web3.js");
+/** Stellar uses RFC 4648 base32; 56 chars, prefixed by G (public key) or C (contract/Soroban). */
 const STELLAR_ADDRESS_RE = /^[A-Z2-7]{56}$/;
+/**
+ * Check if a string is a valid Solana base58 address (including PDAs).
+ * Returns `false` for EVM hex addresses.
+ */
 function isSolanaAddress(address) {
     if (!address)
         return false;
@@ -19,6 +24,11 @@ function isSolanaAddress(address) {
         return false;
     }
 }
+/**
+ * Check if a string is a valid Stellar address.
+ * Muxed accounts (M prefix, per SEP-0023) are intentionally excluded — they are
+ * not valid vault or contract addresses.
+ */
 function isStellarAddress(address) {
     if (!address || typeof address !== 'string')
         return false;
@@ -28,6 +38,7 @@ function isStellarAddress(address) {
         return false;
     return STELLAR_ADDRESS_RE.test(address);
 }
+/** Check if a string is a valid Sui address (0x + 64 hex chars). */
 function isSuiAddress(address) {
     if (!address || typeof address !== 'string')
         return false;

package/lib/core/helpers/core.d.ts

@@ -1,23 +1,65 @@
 import type { INormalizedNumber } from '../../types';
+/**
+ * Table of Contents
+ * - Formatters
+ * - Datetime
+ * - Arrays
+ * - Caching
+ */
 export declare function toNormalizedBn(value: string | bigint | number, decimals?: number | bigint): INormalizedNumber;
+/**
+ * Get fallback RPC URLs for a specific chain
+ */
 export declare function getFallbackRpcUrls(chainId: number): string[];
 export declare const filterOutBySize: (usdAmount: number) => boolean;
+/**
+ * Formatters
+ */
 export declare function toTitleCase(str: string, type?: 'camel'): string;
 export declare function truncate(s: string, amount?: number): string;
+/**
+ * @function round formats any type number value to a standard
+ *
+ * @param value amount to be formatted
+ * @param options.showing amount of decimals to cut off at
+ * @param options.usd if wanting to display USD value
+ * @param options.decimals if passing type bigint, how many decimals to parse to
+ *
+ * @returns standardized string type value
+ */
 export declare function round(value: number | string | bigint, options?: {
     showing?: number | 'all';
     usd?: boolean;
     decimals?: number;
 }): string;
 export declare function loanStateToReadable(loanState: number | bigint): "PREAPPROVED" | "FUNDING_REQUIRED" | "FUNDED" | "ACTIVE" | "CANCELLED" | "MATURED" | "CLOSED";
+/**
+ * Datetime
+ */
 export declare function dateToUnix(date: Date): number;
 export declare function unixToDate(epoch: number): Date;
 export declare function isEarlierThanNow(startTime: Date): boolean;
 export declare function daysAgo(days: number): Date;
 export declare function prepareDateForDb(date: string | Date): string;
+/**
+ * Arrays
+ */
 export declare function orderObjArrByDate(objectArray: any[], options?: {
     key?: string;
     order?: 'asc' | 'desc';
 }): any[];
+/**
+ * Calculate weights based on a specific property in array of objects
+ * @param {Array<Object>} data - Array of objects to calculate weights for
+ * @param {string} weightProperty - Property name to base weights on
+ * @returns {Array<Object>} Original data with weights added
+ */
 export declare function calculateWeights(data?: Array<any>, weightProperty?: string): any[];
+/**
+ * Calculate weighted average for array of objects
+ * @param {Array<Object>} data - Array of objects with values
+ * @param {string} valueProperty - Property name containing the value to average
+ * @param {string} [weightProperty] - Optional property to base weights on
+ * @returns {number} Weighted average
+ */
 export declare function calculateWeightedAverage(data?: Array<any>, valueProperty?: string, weightProperty?: string): any;

package/lib/core/helpers/core.js

@@ -17,23 +17,36 @@ exports.calculateWeights = calculateWeights;
 exports.calculateWeightedAverage = calculateWeightedAverage;
 const web3_1 = require("../constants/web3");
 const ethers_1 = require("ethers");
+/**
+ * Table of Contents
+ * - Formatters
+ * - Datetime
+ * - Arrays
+ * - Caching
+ */
 function toNormalizedBn(value, decimals = 18) {
     if (!value)
         return { normalized: '0', raw: BigInt(0).toString() };
     const sanitize = (val, decimals) => {
         const [whole, frac = ''] = val.split('.');
-        const trimmedFrac = frac.slice(0, decimals);
+        const trimmedFrac = frac.slice(0, decimals); // trim to allowed precision
         return trimmedFrac ? `${whole}.${trimmedFrac}` : whole;
     };
+    // Convert number or exponential string to fixed decimal string
     const toFixedDecimalString = (val) => {
         const strRep = typeof val === 'number' ? String(val) : val;
+        // Check if the string representation contains exponential notation
         if (strRep.includes('e') || strRep.includes('E')) {
+            // Parse as number and use toFixed with high precision to convert exponential to fixed decimal
+            // 100 decimals should handle even extremely small numbers like 1e-20
             const num = typeof val === 'number' ? val : parseFloat(strRep);
             return num.toFixed(100).replace(/\.?0+$/, '');
         }
+        // For regular numbers/strings, return as is
         return strRep;
     };
     if (typeof value === 'string' || typeof value === 'number') {
+        // Convert to fixed decimal string to avoid exponential notation
         const strVal = toFixedDecimalString(value);
         const safeVal = sanitize(strVal, Number(decimals));
         return {
@@ -48,11 +61,17 @@ function toNormalizedBn(value, decimals = 18) {
         };
     }
 }
+/**
+ * Get fallback RPC URLs for a specific chain
+ */
 function getFallbackRpcUrls(chainId) {
     return web3_1.FALLBACK_RPC_URLS[chainId] || [];
 }
 const filterOutBySize = (usdAmount) => usdAmount > 3000;
 exports.filterOutBySize = filterOutBySize;
+/**
+ * Formatters
+ */
 function toTitleCase(str, type) {
     if (!str)
         return;
@@ -60,9 +79,11 @@ function toTitleCase(str, type) {
         case 'camel': {
             const words = Array.from(str)
                 .map((letter) => {
+                // letter is uppercase
                 if (letter === letter.toUpperCase()) {
                     return ` ${letter}`;
                 }
+                // else
                 return letter;
             })
                 .join('');
@@ -83,6 +104,11 @@ function toTitleCase(str, type) {
 }
 function truncate(s, amount) {
     if (typeof s !== 'string') {
+        // Leaf string util: importing Logger here would create an import cycle
+        // (helpers/core → logger/index → slack → helpers/core) that the madge CI
+        // check forbids (CLAUDE.md §9). Keep a direct console.error for this
+        // defensive type-guard diagnostic.
+        // biome-ignore lint/suspicious/noConsole: leaf util cannot import Logger without a cycle (CLAUDE.md §9); keep a direct console.error for this defensive type-guard diagnostic.
         if (s !== undefined)
             console.error('#truncate: not a string', s);
         return '';
@@ -93,16 +119,29 @@ function truncate(s, amount) {
         return s;
     return `${s.slice(0, amount ? amount : 4)}...${s.slice(amount ? amount * -1 : -4)}`;
 }
+/**
+ * @function round formats any type number value to a standard
+ *
+ * @param value amount to be formatted
+ * @param options.showing amount of decimals to cut off at
+ * @param options.usd if wanting to display USD value
+ * @param options.decimals if passing type bigint, how many decimals to parse to
+ *
+ * @returns standardized string type value
+ */
 function round(value, options) {
+    // standardize to string
     let _value;
     if (typeof value === 'bigint') {
         _value = toNormalizedBn(value, options.decimals ?? web3_1.FALLBACK_DECIMALS).normalized;
     }
     else {
         _value = String(value);
+        // if string passed includes something like a symbol (i.e. 0.1 ETH --> 0.1)
         if (_value.includes(' '))
             _value = _value.split(' ')[0];
     }
+    // if wanting USD value
     if (options?.usd) {
         const usdFormatter = new Intl.NumberFormat('en-US', {
             style: 'currency',
@@ -113,6 +152,7 @@ function round(value, options) {
             ? usdFormatter.format(valueNumber)
             : '0';
     }
+    // else slice if decimal places is more than 6 and display
     if (_value === '0' || _value === '0.0')
         return '0.000';
     if (options?.showing === 'all') {
@@ -157,6 +197,9 @@ function loanStateToReadable(loanState) {
             return 'CLOSED';
     }
 }
+/**
+ * Datetime
+ */
 function dateToUnix(date) {
     if (!date)
         return Math.floor(new Date().getTime());
@@ -181,28 +224,49 @@ function daysAgo(days) {
 function prepareDateForDb(date) {
     return new Date(date).toISOString();
 }
+/**
+ * Arrays
+ */
 function orderObjArrByDate(objectArray, options) {
     const selectedOrder = options?.order ?? 'desc';
     const selectedKey = options?.key ?? 'date';
     return objectArray.sort((a, b) => {
+        // Turn your strings into dates, and then subtract them
+        // to get a value that is either negative, positive, or zero.
         if (selectedOrder === 'asc')
             return (new Date(a[selectedKey]).valueOf() - new Date(b[selectedKey]).valueOf());
         return (new Date(b[selectedKey]).valueOf() - new Date(a[selectedKey]).valueOf());
     });
 }
+/**
+ * Calculate weights based on a specific property in array of objects
+ * @param {Array<Object>} data - Array of objects to calculate weights for
+ * @param {string} weightProperty - Property name to base weights on
+ * @returns {Array<Object>} Original data with weights added
+ */
 function calculateWeights(data, weightProperty) {
     if (!data || data.length === 0 || !weightProperty)
         return [];
+    // Get total of the property we're using for weight calculation
     const total = data.reduce((sum, item) => sum + item[weightProperty], 0);
+    // Add weight property to each item
     return data.map((item) => ({
         ...item,
         weight: item[weightProperty] / total,
     }));
 }
+/**
+ * Calculate weighted average for array of objects
+ * @param {Array<Object>} data - Array of objects with values
+ * @param {string} valueProperty - Property name containing the value to average
+ * @param {string} [weightProperty] - Optional property to base weights on
+ * @returns {number} Weighted average
+ */
 function calculateWeightedAverage(data, valueProperty, weightProperty) {
     if (!data || data.length === 0 || !valueProperty)
         return 0;
     let weightedData = data;
+    // If no weightProperty specified, use equal weights
     if (!weightProperty) {
         weightedData = data.map((item) => ({
             ...item,
@@ -212,6 +276,7 @@ function calculateWeightedAverage(data, valueProperty, weightProperty) {
     else {
         weightedData = calculateWeights(data, weightProperty);
     }
+    // Calculate weighted average
     const weightedAverage = weightedData.reduce((acc, item) => acc + item[valueProperty] * item.weight, 0);
     return weightedAverage;
 }

package/lib/core/helpers/explorer-link.d.ts

@@ -1,2 +1,16 @@
 import { IAddress, IChainId, IExplorerType } from '../../types';
+/**
+ * Generate a block-explorer URL for an address or transaction hash.
+ *
+ * Returns an empty string when `chain` is falsy or unknown so the return
+ * type stays assignable to `string` — preserves the historical public
+ * shape from before the file split out of `web3.ts`, where the SDK's
+ * `strictNullChecks: false` masked the implicit `undefined` branch and
+ * consumers pinned to `string` via the emitted `.d.ts`.
+ *
+ * @param hex Address or transaction hash
+ * @param chain Chain ID
+ * @param type Explorer view type (`address`, `tx`, `block`)
+ * @returns Full explorer URL, or `''` when `chain` is falsy / unknown.
+ */
 export declare const explorerLink: (hex: IAddress, chain: IChainId, type: IExplorerType) => string;

package/lib/core/helpers/explorer-link.js

@@ -2,6 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.explorerLink = void 0;
 const web3_1 = require("../constants/web3");
+/**
+ * Generate a block-explorer URL for an address or transaction hash.
+ *
+ * Returns an empty string when `chain` is falsy or unknown so the return
+ * type stays assignable to `string` — preserves the historical public
+ * shape from before the file split out of `web3.ts`, where the SDK's
+ * `strictNullChecks: false` masked the implicit `undefined` branch and
+ * consumers pinned to `string` via the emitted `.d.ts`.
+ *
+ * @param hex Address or transaction hash
+ * @param chain Chain ID
+ * @param type Explorer view type (`address`, `tx`, `block`)
+ * @returns Full explorer URL, or `''` when `chain` is falsy / unknown.
+ */
 const explorerLink = (hex, chain, type) => {
     const network = chain ? web3_1.NETWORKS[chain] : undefined;
     if (!network)

package/lib/core/helpers/signer.d.ts

@@ -1,5 +1,31 @@
 import { Signer, Wallet } from 'ethers';
+/**
+ * Signer Compatibility Helpers
+ *
+ * Utilities for supporting both ethers and viem/wagmi signers.
+ * Provides conversion layer from viem WalletClient to ethers Signer.
+ */
+/**
+ * Type guard to check if a signer is from viem/wagmi
+ * @param signer The signer to check
+ * @returns True if the signer is a viem WalletClient
+ */
 export declare function isViemWalletClient(signer: any): boolean;
+/**
+ * Convert a viem WalletClient to an ethers-compatible Signer
+ * Uses the walletClient as a provider and wraps it for ethers compatibility
+ * @param walletClient Viem WalletClient from wagmi or viem
+ * @returns Ethers Signer that can be used with the SDK
+ */
 export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
+/**
+ * Normalize a signer to ensure it's ethers-compatible
+ * Accepts both ethers Signer and viem WalletClient
+ * @param signer Either an ethers Signer or viem WalletClient
+ * @returns Ethers-compatible Signer
+ */
 export declare function normalizeSigner(signer: Signer | Wallet | any): Promise<Signer | Wallet>;
+/**
+ * Type that represents either an ethers signer or a viem wallet client
+ */
 export type CompatibleSigner = Signer | Wallet | any;

package/lib/core/helpers/signer.js

@@ -4,7 +4,19 @@ exports.isViemWalletClient = isViemWalletClient;
 exports.viemToEthersSigner = viemToEthersSigner;
 exports.normalizeSigner = normalizeSigner;
 const ethers_1 = require("ethers");
+/**
+ * Signer Compatibility Helpers
+ *
+ * Utilities for supporting both ethers and viem/wagmi signers.
+ * Provides conversion layer from viem WalletClient to ethers Signer.
+ */
+/**
+ * Type guard to check if a signer is from viem/wagmi
+ * @param signer The signer to check
+ * @returns True if the signer is a viem WalletClient
+ */
 function isViemWalletClient(signer) {
+    // Viem WalletClient has specific properties that ethers Signer doesn't
     return !!(signer &&
         typeof signer === 'object' &&
         'account' in signer &&
@@ -12,17 +24,27 @@ function isViemWalletClient(signer) {
         'transport' in signer &&
         typeof signer.writeContract === 'function');
 }
+/**
+ * Convert a viem WalletClient to an ethers-compatible Signer
+ * Uses the walletClient as a provider and wraps it for ethers compatibility
+ * @param walletClient Viem WalletClient from wagmi or viem
+ * @returns Ethers Signer that can be used with the SDK
+ */
 async function viemToEthersSigner(walletClient) {
     if (!walletClient) {
         throw new Error('WalletClient is required');
     }
+    // Create an EIP-1193 provider from the wallet client
     const { account, chain, transport } = walletClient;
     if (!account) {
         throw new Error('WalletClient must have an account');
     }
+    // Create a custom transport that uses the walletClient
     const provider = new ethers_1.BrowserProvider({
         request: async ({ method, params }) => {
+            // Use the wallet client's transport for all requests
             if (method === 'eth_sendTransaction') {
+                // For transactions, use writeContract or sendTransaction
                 const [tx] = params;
                 return walletClient.sendTransaction({
                     ...tx,
@@ -30,25 +52,42 @@ async function viemToEthersSigner(walletClient) {
                     chain,
                 });
             }
+            // For all other requests, use the transport directly
             return transport({ chain }).request({ method, params });
         },
     }, chain?.id);
+    // Get the signer from the provider
     return provider.getSigner(account.address);
 }
+/**
+ * Type guard to check if a signer is from ethers
+ * @param signer The signer to check
+ * @returns True if the signer is an ethers Signer or Wallet
+ */
 function isEthersSigner(signer) {
+    // Check for ethers Signer/Wallet properties
     return (signer &&
         typeof signer === 'object' &&
         typeof signer.signMessage === 'function' &&
         typeof signer.signTransaction === 'function' &&
         (signer.provider !== undefined || signer._isSigner === true));
 }
+/**
+ * Normalize a signer to ensure it's ethers-compatible
+ * Accepts both ethers Signer and viem WalletClient
+ * @param signer Either an ethers Signer or viem WalletClient
+ * @returns Ethers-compatible Signer
+ */
 async function normalizeSigner(signer) {
+    // If it's already an ethers signer, return as-is
     if (isEthersSigner(signer)) {
         return signer;
     }
+    // If it's a viem wallet client, convert it
     if (isViemWalletClient(signer)) {
         return viemToEthersSigner(signer);
     }
+    // If we can't determine the type, throw an error
     throw new Error('Invalid signer type. Expected ethers Signer, ethers Wallet, or viem WalletClient');
 }
 //# sourceMappingURL=signer.js.map

package/lib/core/helpers/swap-router.d.ts

@@ -1,4 +1,36 @@
 import { IAddress } from '../../types';
+/**
+ * Resolve the `SwapRouter` address for a chain.
+ *
+ * @param chainId - EVM chain ID.
+ * @returns The router address, or `undefined` if no SwapRouter is deployed.
+ * @example
+ * ```ts
+ * const router = getSwapRouterAddress(1);
+ * // '0xAC771209FF2b71EECfF6E85a9AD01db8Ff2618B0'
+ * ```
+ */
 export declare function getSwapRouterAddress(chainId: number): IAddress | undefined;
+/**
+ * Whether a vault has been registered on a `SwapRouter` and should route
+ * its deposits through it. Address comparison is case-insensitive.
+ *
+ * @param vaultAddress - August vault address.
+ * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
+ */
 export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
+/**
+ * Normalize an optional origin code to the value to send on-chain.
+ *
+ * Returns the caller-supplied code when present, otherwise the default
+ * (all-zero) sentinel from {@link ORIGIN_CODES}. Validates that any
+ * supplied code is exactly 32 bytes (66 chars including the `0x` prefix);
+ * the on-chain SwapRouter reverts with `InvalidOrigin` otherwise, but
+ * surfacing the failure here as a typed SDK error gives partners a
+ * grepable Sentry event instead of a generic `execution reverted`.
+ *
+ * @param provided - Optional caller-supplied origin code.
+ * @returns The 32-byte origin code to pass to the router.
+ * @throws {@link AugustValidationError} when `provided` is not a 32-byte hex string.
+ */
 export declare function resolveOriginCode(provided?: `0x${string}`): `0x${string}`;

package/lib/core/helpers/swap-router.js

@@ -5,12 +5,44 @@ exports.vaultUsesSwapRouter = vaultUsesSwapRouter;
 exports.resolveOriginCode = resolveOriginCode;
 const swap_router_1 = require("../constants/swap-router");
 const errors_1 = require("../errors");
+/**
+ * Resolve the `SwapRouter` address for a chain.
+ *
+ * @param chainId - EVM chain ID.
+ * @returns The router address, or `undefined` if no SwapRouter is deployed.
+ * @example
+ * ```ts
+ * const router = getSwapRouterAddress(1);
+ * // '0xAC771209FF2b71EECfF6E85a9AD01db8Ff2618B0'
+ * ```
+ */
 function getSwapRouterAddress(chainId) {
     return swap_router_1.SWAP_ROUTER_ADDRESSES[chainId];
 }
+/**
+ * Whether a vault has been registered on a `SwapRouter` and should route
+ * its deposits through it. Address comparison is case-insensitive.
+ *
+ * @param vaultAddress - August vault address.
+ * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
+ */
 function vaultUsesSwapRouter(vaultAddress) {
     return swap_router_1.VAULTS_USING_SWAP_ROUTER.has(vaultAddress.toLowerCase());
 }
+/**
+ * Normalize an optional origin code to the value to send on-chain.
+ *
+ * Returns the caller-supplied code when present, otherwise the default
+ * (all-zero) sentinel from {@link ORIGIN_CODES}. Validates that any
+ * supplied code is exactly 32 bytes (66 chars including the `0x` prefix);
+ * the on-chain SwapRouter reverts with `InvalidOrigin` otherwise, but
+ * surfacing the failure here as a typed SDK error gives partners a
+ * grepable Sentry event instead of a generic `execution reverted`.
+ *
+ * @param provided - Optional caller-supplied origin code.
+ * @returns The 32-byte origin code to pass to the router.
+ * @throws {@link AugustValidationError} when `provided` is not a 32-byte hex string.
+ */
 function resolveOriginCode(provided) {
     if (provided === undefined)
         return swap_router_1.ORIGIN_CODES.default;

package/lib/core/helpers/vault-version.d.ts

@@ -1,4 +1,5 @@
 import { ITokenizedVault, IVaultVersion, ChainType } from '../../types';
+/** Classify an address by chain family (evm / solana / stellar / sui). */
 export declare function getAddressChainType(address: string): ChainType;
 export declare function getVaultVersion(vault: string): IVaultVersion | undefined;
 export declare function getVaultVersionV2(vault: ITokenizedVault): IVaultVersion | undefined;

package/lib/core/helpers/vault-version.js

@@ -6,6 +6,7 @@ exports.getVaultVersionV2 = getVaultVersionV2;
 const ethers_1 = require("ethers");
 const vaults_1 = require("../constants/vaults");
 const chain_address_1 = require("./chain-address");
+/** Classify an address by chain family (evm / solana / stellar / sui). */
 function getAddressChainType(address) {
     if ((0, chain_address_1.isStellarAddress)(address))
         return 'stellar';
@@ -15,6 +16,7 @@ function getAddressChainType(address) {
         return 'sui';
     return 'evm';
 }
+// @todo: move to backend
 function getVaultVersion(vault) {
     if (!vault)
         return;

package/lib/core/helpers/vaults.d.ts

@@ -1,4 +1,8 @@
 import { IAddress, IContractRunner } from '../../types';
+/**
+ * Bad transactions that should be ignored
+ * these transactions are usually from tests and can skew data
+ */
 export declare const isBadTransaction: (hash: string, chainId: number) => boolean;
 export declare const isBadVault: (address?: string) => boolean;
 import { getAddressChainType, getVaultVersion, getVaultVersionV2 } from './vault-version';
@@ -6,6 +10,10 @@ export { getAddressChainType, getVaultVersion, getVaultVersionV2 };
 export declare const REWARD_DISTRIBUTOR_ADDRESS: (chainId: number) => string[];
 export declare const AVAX_PRICE_FEED_ADDRESS: (chainId: number) => "0xFF3EEb22B5E3dE6e705b44749C2559d704923FD7" | "0x";
 export declare function getVaultSymbol(vault: IAddress, provider: IContractRunner): Promise<string | undefined>;
+/**
+ * @deprecated
+ * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
+ */
 export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool?: IAddress) => {
     1: string;
     8453: string;

package/lib/core/helpers/vaults.js

@@ -8,10 +8,16 @@ const web3_1 = require("./web3");
 const chain_address_1 = require("./chain-address");
 const vault_metadata_1 = require("../vault-metadata");
 const logger_1 = require("../logger");
+/** @internal */
 const VAULT_SYMBOLS_LOWERCASE = Object.fromEntries(Object.entries(vaults_1.VAULT_SYMBOLS).map(([k, v]) => [k.toLowerCase(), v]));
+/**
+ * Bad transactions that should be ignored
+ * these transactions are usually from tests and can skew data
+ */
 const isBadTransaction = (hash, chainId) => {
     const badTxs = {
         1: [
+            // farmBOLD deposit test tx due to a decimal error
             '0xaba75b16e74a7a2457bfdcded853edd2bb4d3b305919baf84fb1f6b54b864889',
             '0xc4c30185198672cbc91a95520d1bf91634ece37c199b2f1f15d29e8290c7ed4b',
             '0x8e319576413897d1750f16bb93c7f59759b5bbafcb5bd9ef956f6bc0b0314aef',
@@ -36,21 +42,21 @@ const isBadVault = (address) => {
         case (0, ethers_1.getAddress)('0x706162790b601A8514c18718d0c63C9D1268e89C'):
             return true;
         case (0, ethers_1.getAddress)('0xd684AF965b1c17D628ee0d77cae94259c41260F4'):
-            return true;
+            return true; // ETH: sUSDe
         case (0, ethers_1.getAddress)('0xB78dAf3fD674B81ebeaaa88d711506fa069E1C5E'):
-            return true;
+            return true; // ETH: ETH Optimizer
         case (0, ethers_1.getAddress)('0x4e2D90f0307A93b54ACA31dc606F93FE6b9132d2'):
-            return true;
+            return true; // Base: LBTC
         case (0, ethers_1.getAddress)('0x18a5a3D575F34e5eBa92ac99B0976dBe26f9F869'):
-            return true;
+            return true; // ETH: LBTC
         case (0, ethers_1.getAddress)('0xD0b717ef23817b1a127139830Cf0FcD449ef74F0'):
-            return true;
+            return true; // BNB: Sienna USDT Tulipa
         case (0, ethers_1.getAddress)('0xeb402fc96C7ed2f889d837C9976D6d821c1B5f01'):
-            return true;
+            return true; // ETH: Kelp TAC Vault
         case (0, ethers_1.getAddress)('0xEBac5e50003d4B17Be422ff9775043cD61002f7f'):
-            return true;
+            return true; // ETH: Upshift BTC
         case (0, ethers_1.getAddress)('0x419386E3Ef42368e602720CC458e00c0B28c47A7'):
-            return true;
+            return true; // ETH: Kelp TAC Vault
         default:
             return false;
     }
@@ -60,6 +66,7 @@ const vault_version_1 = require("./vault-version");
 Object.defineProperty(exports, "getAddressChainType", { enumerable: true, get: function () { return vault_version_1.getAddressChainType; } });
 Object.defineProperty(exports, "getVaultVersion", { enumerable: true, get: function () { return vault_version_1.getVaultVersion; } });
 Object.defineProperty(exports, "getVaultVersionV2", { enumerable: true, get: function () { return vault_version_1.getVaultVersionV2; } });
+// Used for Upshift
 const REWARD_DISTRIBUTOR_ADDRESS = (chainId) => {
     switch (chainId) {
         case 43114:
@@ -72,6 +79,7 @@ const REWARD_DISTRIBUTOR_ADDRESS = (chainId) => {
     }
 };
 exports.REWARD_DISTRIBUTOR_ADDRESS = REWARD_DISTRIBUTOR_ADDRESS;
+// Used for Upshift
 const AVAX_PRICE_FEED_ADDRESS = (chainId) => {
     switch (chainId) {
         case 1:
@@ -108,16 +116,22 @@ async function getVaultSymbol(vault, provider) {
     const symbol = await (0, web3_1.getSymbol)(provider, vault);
     return symbol;
 }
+/**
+ * @deprecated
+ * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
+ */
 const SUBGRAPH_POOL_URLS = (apiKey, chainId, pool) => {
     if (chainId === 999) {
         if (!pool) {
             throw new Error(`Pool address is required for chainId ${chainId}`);
         }
         switch (pool) {
+            // hbHYPE
             case '0x96C6cBB6251Ee1c257b2162ca0f39AA5Fa44B1FB':
                 return {
                     999: 'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-hyperevm-hyperbeat/1.0.0/gn',
                 };
+            // hbBTC
             case '0xc061d38903b99aC12713B550C2CB44B221674F94':
                 return {
                     999: 'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-hyperevm-hbBTC/1.0.0/gn',