upshift-finance 1.0.0

package/lib/main.js

@@ -0,0 +1,601 @@
+"use strict";
+/**
+ * The main August SDK class.
+ *
+ * @module AugustSDK
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AugustSDK = void 0;
+const solana_1 = __importDefault(require("./adapters/solana"));
+const sui_1 = __importDefault(require("./adapters/sui"));
+const stellar_1 = __importDefault(require("./adapters/stellar"));
+const evm_1 = __importDefault(require("./adapters/evm"));
+const core_1 = require("./core");
+const vaults_1 = require("./modules/vaults");
+const analytics_1 = require("./core/analytics");
+const sub_accounts_1 = require("./modules/sub-accounts");
+const api_1 = require("./modules/api");
+/**
+ * Main SDK class for interacting with August Digital vaults and services.
+ * Provides unified access to EVM, Solana, Sui, and Stellar blockchain adapters.
+ */
+class AugustSDK extends core_1.AugustBase {
+    vaults;
+    subaccounts;
+    api;
+    solana;
+    sui;
+    stellar;
+    evm;
+    /**
+     * Initialize the August SDK with provider configuration.
+     * Automatically sets up EVM adapter and optionally initializes Solana if RPC URL is provided.
+     */
+    constructor(baseConfig) {
+        super(baseConfig);
+        // @todo: change this later when august key is required
+        this.authorized = true;
+        // EVM adapter is always available
+        this.evm = new evm_1.default();
+        // @solana: handle solana service initialization
+        //
+        // Two accepted entry points, treated as exclusive sources so url+network
+        // can never come from different configs:
+        //   1) `baseConfig.solana = { rpcUrl, network }` — preferred. Both fields
+        //      come from the same place; the caller controls the network.
+        //   2) `baseConfig.providers[-1] = rpcUrl` — legacy "Solana as another
+        //      EVM chain" shape. Network is derived from the URL substring.
+        //
+        // Without one of these `this.solana` stays undefined and every Solana
+        // vault is silently dropped from getVaults / getVaultPositions (the
+        // filter in modules/vaults/main.ts gates on `!!this.solanaService`).
+        const solanaConfig = (() => {
+            if (baseConfig.solana?.rpcUrl) {
+                return {
+                    rpcUrl: baseConfig.solana.rpcUrl,
+                    network: baseConfig.solana.network,
+                };
+            }
+            const legacyRpcUrl = baseConfig.providers?.[core_1.SPECIAL_CHAINS.solana.chainId];
+            if (legacyRpcUrl) {
+                return {
+                    rpcUrl: legacyRpcUrl,
+                    network: legacyRpcUrl.includes('devnet')
+                        ? 'devnet'
+                        : 'mainnet-beta',
+                };
+            }
+            return null;
+        })();
+        if (solanaConfig) {
+            this.solana = new solana_1.default(solanaConfig.rpcUrl, solanaConfig.network);
+            (0, analytics_1.instrumentClass)(this.solana, () => core_1.SPECIAL_CHAINS.solana.chainId);
+        }
+        this.sui = new sui_1.default();
+        // @stellar: mirror the Solana injection — the consumer may supply a keyed
+        // Soroban RPC (e.g. Alchemy) via `baseConfig.stellar`; otherwise the adapter
+        // uses its built-in public endpoints. Endpoint is injected, not hardcoded.
+        this.stellar = new stellar_1.default(baseConfig.stellar?.network, {
+            sorobanRpcUrl: baseConfig.stellar?.rpcUrl,
+        });
+        this.vaults = new vaults_1.AugustVaults(baseConfig, this.solana, this.sui);
+        this.subaccounts = new sub_accounts_1.AugustSubAccounts(baseConfig);
+        this.api = new api_1.AugustApi(baseConfig);
+        // Instrument all SDK methods for analytics tracking
+        (0, analytics_1.instrumentClass)(this, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.evm, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.sui, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.stellar, () => core_1.SPECIAL_CHAINS.stellar?.chainId);
+        (0, analytics_1.instrumentClass)(this.vaults, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.subaccounts, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.api, () => this.activeNetwork?.chainId);
+    }
+    /**
+     * Get the Sub-Accounts module instance.
+     */
+    get subAccountsModule() {
+        return this.subaccounts;
+    }
+    /**
+     * Get the Vaults module instance.
+     */
+    get vaultsModule() {
+        return this.vaults;
+    }
+    /**
+     * Get the backend API module instance ({@link AugustApi}) — read-only
+     * access to backend-computed data with no on-chain equivalent
+     * (unrealized-PnL series).
+     */
+    get apiModule() {
+        return this.api;
+    }
+    /**
+     * Switch the active network for vault operations.
+     * Updates the SDK's active chain and RPC provider.
+     */
+    switchNetwork(chainId) {
+        super.switchNetwork(chainId);
+        this.vaults.switchNetwork(chainId);
+        // Track network switch for analytics
+        (0, analytics_1.trackNetworkSwitch)(chainId);
+    }
+    /**
+     * Set the active wallet address for tracking user-specific vault data.
+     * Updates monitoring headers with the wallet address.
+     */
+    updateWallet(address) {
+        if (!address)
+            return;
+        if (this.monitoring) {
+            this.monitoring['x-user-id'] = address;
+        }
+        this.vaults.updateWallet(address);
+    }
+    /**
+     * Clear the active wallet address from the SDK state and monitoring headers.
+     */
+    clearWallet() {
+        if (this.monitoring) {
+            this.monitoring['x-user-id'] = undefined;
+        }
+        this.vaults.clearWallet();
+    }
+    /**
+     * Pricing and Market Data
+     */
+    /**
+     * Get the current USD price of a token by symbol or contract address.
+     * Falls back to CoinGecko if primary price source fails.
+     *
+     * @param symbol - Token symbol or contract address
+     * @returns Current price in USD
+     */
+    async getPrice(symbol) {
+        if (!this.authorized)
+            throw new Error('Not authorized.');
+        if (!symbol)
+            throw new Error(`Symbol input parameter is not defined.`);
+        return await (0, core_1.fetchTokenPrice)(symbol, null, this.keys?.coingecko);
+    }
+    /**
+     * Vault Data and Operations
+     */
+    /**
+     * Fetch all available vaults across configured networks.
+     * Optionally filter by chain IDs and include loan/allocation data.
+     * @param options - Configuration for filtering and enriching vault data
+     * @returns Array of vault objects with metadata and optional position data
+     */
+    async getVaults(options) {
+        return await this.vaults.getVaults(options);
+    }
+    async getTotalDeposited(options) {
+        return await this.vaults.getTotalDeposited(options);
+    }
+    /**
+     * Fetch all available vaults across configured networks.
+     * Optionally filter by chain IDs and include loan/allocation data.
+     * @param options - Configuration for filtering and enriching vault data
+     * @returns Array of vault objects with metadata and optional position data
+     */
+    async vaultDeposit(signer, options) {
+        return await this.vaults.vaultDeposit(signer, options);
+    }
+    /**
+     * Fetch detailed information for a specific vault.
+     * @param props - Vault address, chain ID, and optional enrichment options
+     * @returns Single vault object with full metadata
+     */
+    async getVault(props) {
+        return await this.vaults.getVault(props);
+    }
+    /**
+     * Get active loans deployed from a vault.
+     * @param props - Vault address and chain ID
+     * @returns Array of loan details including borrower, principal, APR
+     */
+    async getVaultLoans(props) {
+        return await this.vaults.getVaultLoans(props);
+    }
+    /**
+     * Get vault asset allocations across DeFi protocols, CeFi, and OTC positions.
+     * @param props - Vault address and chain ID
+     * @returns Detailed breakdown of vault allocations by category
+     */
+    async getVaultAllocations(props) {
+        return await this.vaults.getVaultAllocations(props);
+    }
+    /**
+     * Get current or historical APY for a vault.
+     *
+     * @deprecated use getVaultHistoricalTimeseries instead
+     *
+     * @param props - Vault address and optional historical lookback period
+     * @returns APY data including rewards breakdown
+     */
+    async getVaultApy(props) {
+        return await this.vaults.getVaultApy(props);
+    }
+    /**
+     * Get current or historical TVL for a vault.
+     * @param props - Vault address and optional historical parameters
+     * @returns TVL in vault's base asset units
+     */
+    async getVaultTvl(props) {
+        return await this.vaults.getVaultTvl(props);
+    }
+    /**
+     * Get historical timeseries data for a vault.
+     * @param props - Vault address and optional number of days
+     * @returns Historical timeseries data with TVL, APY, PnL, share price, and other metrics
+     */
+    async getVaultHistoricalTimeseries(props) {
+        return await this.vaults.getVaultHistoricalTimeseries(props);
+    }
+    /**
+     * Get the timestamp when yield was last realized for a vault.
+     * @param props - Vault address and optional chain ID
+     * @returns Timestamp (Unix timestamp in seconds) when yield was last realized
+     */
+    async getYieldLastRealizedOn(props) {
+        return await this.vaults.getYieldLastRealizedOn(props);
+    }
+    /**
+     * Get redemption requests that are ready to be claimed.
+     * @param props - Vault address, chain ID, and optional wallet filter
+     * @returns Array of available redemption requests with amounts and timestamps
+     */
+    async getVaultAvailableRedemptions(props) {
+        return await this.vaults.getVaultAvailableRedemptions(props);
+    }
+    /**
+     * Get historical redemption requests for a vault (settled, cancelled,
+     * pending-but-out-of-window), optionally filtered to one wallet.
+     *
+     * @param props - Vault address, chain ID, optional wallet, and an
+     *   optional `lookbackBlocks` for how far back to scan.
+     * @returns Historical redemption records, newest first.
+     */
+    async getVaultRedemptionHistory(props) {
+        return await this.vaults.getVaultRedemptionHistory(props);
+    }
+    /**
+     * Get user positions across vaults including shares and claimable redemptions.
+     * Supports both EVM and Solana vaults.
+     * @param props - Wallet address, chain ID, and optional vault filter
+     * @returns Array of positions with balances and pending redemptions
+     */
+    async getVaultPositions(props) {
+        return await this.vaults.getVaultPositions(props);
+    }
+    /**
+     * Get user's historical vault interactions including deposits and withdrawals.
+     * @param props - Wallet address and optional vault/chain filters
+     * @returns Array of historical transactions with amounts and timestamps
+     */
+    async getVaultUserHistory(props) {
+        return await this.vaults.getUserHistory(props);
+    }
+    /**
+     * Get user's vault share transfer history from subgraph.
+     * @param props - Wallet address and optional vault/chain filters
+     * @returns Array of transfer events
+     */
+    async getVaultUserTransfers(props) {
+        return await this.vaults.getUserTransfers(props);
+    }
+    /**
+     * Get a vault's deposit/withdrawal activity across every participant.
+     *
+     * The vault-wide counterpart to {@link AugustSDK.getVaultUserHistory} — use
+     * it to answer flow questions ("how many deposits in the last 7 days", "net
+     * flow this week") that point-in-time TVL cannot. Reads from the Goldsky
+     * subgraph, paginated so busy vaults are not truncated; a `sinceTs` window
+     * keeps short lookbacks cheap.
+     * @param props - Vault address, optional chain id, optional `sinceTs`/`untilTs`
+     * Unix-second bounds, and an optional `types` filter.
+     * @returns Array of activity items (oldest-first) with normalized amounts,
+     * actor addresses, event type, and transaction hashes.
+     * @throws If `vault` is not a valid address or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const items = await sdk.getVaultActivity({ vault, chainId: 143, sinceTs: weekAgo });
+     * ```
+     */
+    async getVaultActivity(props) {
+        return await this.vaults.getVaultActivity(props);
+    }
+    /**
+     * Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a
+     * chain — the any-token set a deposit UI can offer as swap-and-deposit inputs.
+     *
+     * Delegates to {@link AugustVaults.getSwapRouterWhitelistedTokens}, which
+     * reconstructs the set from the router's `TokenEnabled` events and verifies
+     * each against the on-chain `whitelistedTokens` mapping (not enumerable).
+     * Returns `[]` when no router is deployed on `chainId` or no provider is
+     * configured for it.
+     *
+     * @param chainId - EVM chain ID to resolve the allowlist for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed whitelisted token addresses; `[]` when unavailable.
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const tokens = await augustSdk.getSwapRouterWhitelistedTokens(1);
+     * ```
+     */
+    async getSwapRouterWhitelistedTokens(chainId, options) {
+        return await this.vaults.getSwapRouterWhitelistedTokens(chainId, options);
+    }
+    /**
+     * Resolve the vaults currently eligible for the any-token `SwapRouter`
+     * deposit surface on a chain — every vault the router has `enableVault`-ed
+     * whose on-chain registration is still live.
+     *
+     * Delegates to {@link AugustVaults.getSwapRouterEligibleVaults}, which
+     * reconstructs the set from the router's `VaultEnabled` events and verifies
+     * each vault's current `vaultInfo` registration (not enumerable). Returns
+     * `[]` when no router is deployed on `chainId` or no provider is configured
+     * for it. On-chain eligibility only — app-level policy (e.g. OVault
+     * exclusions) remains the caller's responsibility.
+     *
+     * @param chainId - EVM chain ID to resolve eligible vaults for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed eligible vault addresses; `[]` when unavailable.
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const vaults = await augustSdk.getSwapRouterEligibleVaults(1);
+     * ```
+     */
+    async getSwapRouterEligibleVaults(chainId, options) {
+        return await this.vaults.getSwapRouterEligibleVaults(chainId, options);
+    }
+    /**
+     * Get lifetime PnL for a user in a specific vault.
+     * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.
+     * @param props - Vault address, wallet address, and optional chain ID
+     * @returns Lifetime PnL data including realized and unrealized PnL in both native token and USD
+     */
+    async getVaultUserLifetimePnl(props) {
+        return await this.vaults.getVaultUserLifetimePnl(props);
+    }
+    /**
+     * Get PnL for a vault (vault-level, not user-specific).
+     * Returns the vault's overall profit and loss across all users.
+     * @param props - Vault address and optional chain ID
+     * @returns Vault PnL in USD and notional value
+     */
+    async getVaultPnl(props) {
+        return await this.vaults.getVaultPnl(props);
+    }
+    /**
+     * Get user's staking positions for vault receipt tokens.
+     * @param props - Wallet address and optional chain ID
+     * @returns Array of staking positions with rewards
+     */
+    async getVaultStakingPositions(props) {
+        return await this.vaults.getStakingPositions(props.wallet, props.chainId);
+    }
+    /**
+     * Get the borrower's health factor by vault.
+     *
+     * Pass `vault` whenever the caller knows which pool it cares about — it
+     * skips the all-vaults cross-chain fanout and only reads the loans for
+     * that one pool. The response map is keyed by **lowercased** vault
+     * address; look entries up with `address.toLowerCase()`.
+     *
+     * @param props.chainId Optional chain to scope the read to.
+     * @param props.vault Optional vault address. When provided alongside
+     *   `chainId`, only that vault's borrower-health-factor data is fetched.
+     * @returns Object containing the borrower's health factor by vault.
+     */
+    async getVaultBorrowerHealthFactor(props) {
+        return await this.vaults.getVaultBorrowerHealthFactor(props?.chainId, props?.vault);
+    }
+    /**
+     * Get user points from the backend API.
+     * This fetches processed points data directly from the backend,
+     * removing the need for client-side points calculation.
+     * @param userAddress - User wallet address
+     * @returns Points data from the backend API
+     */
+    async getUserPoints(userAddress) {
+        return await this.vaults.getUserPoints(userAddress);
+    }
+    /**
+     * Register a user for the points program, authenticated by a wallet signature.
+     *
+     * The caller produces a personal_sign signature over a canonical message
+     * containing the user address, referrer (or `"none"`), chain, nonce, and
+     * expiry — see `AugustVaults.registerUserForPoints` for the exact template.
+     *
+     * @param userAddress - EVM wallet address being registered.
+     * @param referrerAddress - Optional EVM referrer address.
+     * @param chainId - Chain on which the wallet signed; powers the EIP-1271
+     *   fallback for smart-contract wallets and pins the signature cross-chain.
+     * @param signature - 0x-prefixed personal_sign signature over the canonical message.
+     * @param nonce - Single-use random string (8–128 chars).
+     * @param expiry - Unix seconds; must be in the future, within the backend's TTL.
+     * @returns Raw `Response` from the backend.
+     */
+    async registerUserForPoints(userAddress, referrerAddress, chainId, signature, nonce, expiry) {
+        return await this.vaults.registerUserForPoints(userAddress, referrerAddress, chainId, signature, nonce, expiry);
+    }
+    /**
+     * Fetch the points leaderboard data.
+     * @param params - Optional parameters for pagination and sorting
+     * @returns Leaderboard response data
+     */
+    async fetchPointsLeaderboard(params) {
+        return await this.vaults.fetchPointsLeaderboard(params);
+    }
+    /**
+     * Fetch the historical unrealized-PnL series for a vault, newest first.
+     * Delegates to {@link AugustApi.getVaultUnrealizedPnlHistory} — see it for
+     * parameter semantics and thrown errors.
+     */
+    async getVaultUnrealizedPnlHistory(params) {
+        return await this.api.getVaultUnrealizedPnlHistory(params);
+    }
+    /**
+     * Fetch the latest unrealized-PnL snapshot for every tracked vault.
+     * Delegates to {@link AugustApi.getLatestUnrealizedPnl} — see it for
+     * return shape and thrown errors.
+     */
+    async getLatestUnrealizedPnl() {
+        return await this.api.getLatestUnrealizedPnl();
+    }
+    /**
+     * Get annualized APY metrics for a vault.
+     *
+     * Supported Vaults: cUSDO, tETH, wstETH, rsETH
+     *
+     * @deprecated The `hgETH30dLiquidAPY` and `hgETH7dLiquidAPY` response fields are deprecated.
+     * These fields will be removed on 2026-01-01.
+     * Use `liquidAPY30Day` and `liquidAPY7Day` fields instead.
+     *
+     * @param props - Vault address
+     * @returns Annualized APY data including liquidity APY
+     */
+    async getVaultAnnualizedApy(props) {
+        return await this.vaults.getVaultAnnualizedApy(props.vault);
+    }
+    /**
+     * Get summary data for a vault (name, type, chain, recent returns).
+     * @param props - Vault address
+     * @returns Vault summary data
+     */
+    async getVaultSummary(props) {
+        return await this.vaults.getVaultSummary(props.vault);
+    }
+    /**
+     * Get withdrawal summary and pending queue for a vault.
+     * @param props - Vault address and optional chain ID
+     * @returns Withdrawal summary and pending queue
+     */
+    async getVaultWithdrawals(props) {
+        return await this.vaults.getVaultWithdrawals(props.vault, props.chainId);
+    }
+    /**
+     * Preview the amount of assets that would be received for redeeming shares (queued redemption).
+     * @param props - Vault contract address, shares amount, and optional chain ID
+     * @returns The amount of assets as {@link INormalizedNumber}
+     */
+    async previewRedemption(props) {
+        return await this.vaults.previewRedemption(props);
+    }
+    /**
+     * Query LayerZero USDC deposits from the august-layerzero subgraphs.
+     * Returns all deposits or filters by sender wallet address if provided.
+     *
+     * **Important Notes:**
+     * - Only deposit transactions are tracked (not withdrawals or other operations)
+     * - Sender and recipient addresses are stored in bytes32 format in the subgraph
+     * - Timestamps are available from the subgraph
+     *
+     * **Supported Vaults:**
+     * - `upusdc`: 0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42
+     * - `coreusdc`: 0xE9B725010A9E419412ed67d0fA5f3A5f40159D32
+     * - `earnausd`: 0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA
+     *
+     * @param props - Receipt token type ('upusdc', 'coreusdc', or 'earnausd') and optional wallet address to filter by sender
+     * @returns Array of deposit events with the following structure:
+     * - `assetAmt`: Amount of assets deposited (as string)
+     * - `shareAmt`: Amount of shares received (as string)
+     * - `sender`: Sender address in bytes32 format
+     * - `recipient`: Recipient address in bytes32 format
+     * - `dstEid`: Destination endpoint ID (LayerZero chain identifier)
+     * - `transactionHash_`: Transaction hash
+     *
+     * @throws Error if receipt token is invalid or GraphQL request fails
+     *
+     * @example
+     * ```typescript
+     * // Get all coreUSDC deposits
+     * const allDeposits = await sdk.getLayerZeroDeposits({
+     *   receiptToken: 'coreusdc'
+     * });
+     *
+     * // Get deposits for a specific wallet
+     * const userDeposits = await sdk.getLayerZeroDeposits({
+     *   receiptToken: 'upusdc',
+     *   wallet: '0xb0280B58F541131b29D1B33319CD440a99eA0305'
+     * });
+     * ```
+     */
+    async getLayerZeroDeposits(props) {
+        // Runtime validation for receipt token
+        const validTokens = ['upusdc', 'coreusdc', 'earnausd'];
+        if (!validTokens.includes(props.receiptToken)) {
+            throw new Error(`Invalid receiptToken: ${props.receiptToken}. Must be 'upusdc', 'coreusdc', or 'earnausd'.`);
+        }
+        const { queryLayerZeroDeposits } = await Promise.resolve().then(() => __importStar(require('./services/layerzero/deposits')));
+        // Map receipt token to vault key
+        const vaultKeyMap = {
+            upusdc: 'upUSDC',
+            coreusdc: 'coreUSDC',
+            earnausd: 'earnAUSD',
+        };
+        const vaultKey = vaultKeyMap[props.receiptToken];
+        return await queryLayerZeroDeposits(vaultKey, props.wallet);
+    }
+    /**
+     * Get LayerZero redeems for earnAUSD vault
+     *
+     * @example
+     * ```typescript
+     * // Get all earnAUSD redeems
+     * const allRedeems = await sdk.getLayerZeroRedeems();
+     *
+     * // Get redeems for a specific wallet
+     * const userRedeems = await sdk.getLayerZeroRedeems({
+     *   wallet: '0x2de1DCB8EaAd40fAd327fa3eE3F48774b8e20649'
+     * });
+     * ```
+     */
+    async getLayerZeroRedeems(props) {
+        const { queryLayerZeroRedeems } = await Promise.resolve().then(() => __importStar(require('./services/layerzero/redeems')));
+        return await queryLayerZeroRedeems(props?.wallet);
+    }
+}
+exports.AugustSDK = AugustSDK;
+//# sourceMappingURL=main.js.map

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

@@ -0,0 +1,82 @@
+import { type IFetchAugustOptions } from '../../core';
+import type { ICollateralExcessOrDeficit, ICollateralSimulationInput, ICollateralSimulationResults, ICuratorWhitelistStatus, IDiscountFactorLadder, ILoanBookInfo, IOracleClassification, IOtcMarginRequirement, IOtcPositionRead, IRevertReason, ITimelockRequest, IVaultPerformanceFees, IWSSubaccountListItem } from '../../types';
+/**
+ * Fetch the global loan-book aggregate (admin-only `GET /dashboard/loans`).
+ */
+export declare const fetchDashboardLoans: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ILoanBookInfo[]>;
+/**
+ * Fetch every token discount-factor ladder (`GET /risk/discount_factors`).
+ */
+export declare const fetchDiscountFactors: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IDiscountFactorLadder[]>;
+/**
+ * Fetch a subaccount's collateral excess/deficit for one token
+ * (`GET /risk/collateral_excess_or_deficit`).
+ */
+export declare const fetchCollateralExcessOrDeficit: (params: {
+    subaccount: string;
+    tokenAddress: string;
+    tokenChain: number;
+    targetHealthFactor?: number;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICollateralExcessOrDeficit>;
+/**
+ * Run a collateral simulation (`POST /risk/collateral_simulation`). This is a
+ * pure, read-only simulation — the backend computes required collateral for a
+ * hypothetical loan and changes no state.
+ */
+export declare const fetchCollateralSimulation: (body: ICollateralSimulationInput, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICollateralSimulationResults>;
+/**
+ * Fetch the decoded revert reason(s) for a transaction from the public
+ * `GET /revert_reason` endpoint. No API key required.
+ */
+export declare const fetchRevertReason: (txHash: string, chain: number, headers?: IFetchAugustOptions["headers"]) => Promise<IRevertReason>;
+/**
+ * Fetch all OTC positions (admin-only `GET /otc/position`).
+ */
+export declare const fetchOtcPositions: (augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IOtcPositionRead[]>;
+/**
+ * Fetch OTC margin requirements (admin-only `GET /otc/margin_requirement`),
+ * optionally filtered by counterparty id and/or payer.
+ */
+export declare const fetchOtcMarginRequirements: (filters: {
+    otcCounterpartyId?: string;
+    payer?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IOtcMarginRequirement[]>;
+/**
+ * Fetch the subaccounts linked to a vault (curator-or-admin
+ * `GET /curator/vaults/{vault_address}/subaccounts`).
+ */
+export declare const fetchCuratorVaultSubaccounts: (vaultAddress: string, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IWSSubaccountListItem[]>;
+/**
+ * Fetch on-chain whitelist status for a vault's subaccounts (curator-or-admin
+ * `GET /curator/vaults/{vault_address}/whitelist`). EVM vaults only — the
+ * backend 400s for non-EVM vaults.
+ */
+export declare const fetchCuratorVaultWhitelist: (vaultAddress: string, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ICuratorWhitelistStatus[]>;
+/**
+ * Fetch timelock requests for a vault on a chain (`GET /timelock-requests`),
+ * optionally filtered by status.
+ */
+export declare const fetchTimelockRequests: (params: {
+    vaultAddress: string;
+    chainId: number;
+    status?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<ITimelockRequest[]>;
+/**
+ * Fetch a vault's performance-fee computation
+ * (`GET /metrics/vault_performance_fees`). Slow first call (pandas over full
+ * snapshot history); 20-minute server-side cache.
+ */
+export declare const fetchVaultPerformanceFees: (params: {
+    vaultAddress: string;
+    annualizedFeesPct: number;
+    nativeDenominated: boolean;
+    calculationPeriod: string;
+    startDate?: string;
+    endDate?: string;
+}, augustKey: string, headers?: IFetchAugustOptions["headers"]) => Promise<IVaultPerformanceFees>;
+/**
+ * Fetch a vault's NAV-oracle classification table from the public
+ * `GET /upshift/oracle_classification/{vault_address}` endpoint. No API key
+ * required.
+ */
+export declare const fetchVaultOracleClassification: (vaultAddress: string, chainId: number, headers?: IFetchAugustOptions["headers"]) => Promise<IOracleClassification>;