@elmntl/jlpd-sdk 0.2.0 → 0.13.5

package/dist/jlpd-strategy/jlp-data.js

@@ -0,0 +1,611 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__test__resetPricesCache = __test__resetPricesCache;
+exports.fetchJlpPoolDetails = fetchJlpPoolDetails;
+exports.computeAddLiquidityFee = computeAddLiquidityFee;
+exports.fetchJlpCustodyData = fetchJlpCustodyData;
+exports.computeEffectiveUsd = computeEffectiveUsd;
+exports.fetchJlpEffectiveWeights = fetchJlpEffectiveWeights;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const CUSTODIES = [
+    {
+        name: "SOL",
+        address: new web3_js_1.PublicKey("7xS2gz2bTp3fwCC7knJvUWTEU9Tycczu6VhJYKgi1wdz"),
+        decimals: 9,
+        isStable: false,
+        mintAddress: "So11111111111111111111111111111111111111112",
+    },
+    {
+        name: "ETH",
+        address: new web3_js_1.PublicKey("AQCGyheWPLeo6Qp9WpYS9m3Qj479t7R636N9ey1rEjEn"),
+        decimals: 8,
+        isStable: false,
+        mintAddress: "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs",
+    },
+    {
+        name: "WBTC",
+        address: new web3_js_1.PublicKey("5Pv3gM9JrFFH883SWAhvJC9RPYmo8UNxuFtv5bMMALkm"),
+        decimals: 8,
+        isStable: false,
+        mintAddress: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh",
+    },
+    {
+        name: "USDC",
+        address: new web3_js_1.PublicKey("G18jKKXQwBbrHeiK3C9MRXhkHsLHf7XgCSisykV46EZa"),
+        decimals: 6,
+        isStable: true,
+        mintAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    },
+    {
+        name: "USDT",
+        address: new web3_js_1.PublicKey("4vkNeXiYEUizLdrpdPS1eC2mccyM4NUPRtERrk6ZETkk"),
+        decimals: 6,
+        isStable: true,
+        mintAddress: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    },
+];
+// ---------------------------------------------------------------------------
+// Custody account byte offsets (Jupiter Perps on-chain layout)
+// ---------------------------------------------------------------------------
+const OFFSET_TARGET_RATIO_BPS = 206; // u64 LE, custody target weight (right before assets)
+const OFFSET_ASSETS = 214;
+const OFFSET_ASSETS_OWNED = OFFSET_ASSETS + 8;
+const OFFSET_ASSETS_LOCKED = OFFSET_ASSETS + 16;
+const OFFSET_ASSETS_GUARANTEED_USD = OFFSET_ASSETS + 24;
+const OFFSET_ASSETS_GLOBAL_SHORT_SIZES = OFFSET_ASSETS + 32;
+const OFFSET_ASSETS_GLOBAL_SHORT_AVG_PX = OFFSET_ASSETS + 40;
+const OFFSET_DEBT = 1004;
+const OFFSET_BORROW_LEND_INTERESTS_ACCRUED = 1020;
+const SCALE_USD = 1e6;
+const DEBT_MULTIPLIER = 1e9;
+const JUPITER_PRICE_API = "https://lite-api.jup.ag/price/v3";
+// ---------------------------------------------------------------------------
+// Binary parsing helpers
+// ---------------------------------------------------------------------------
+function u64FromLE(buf, offset) {
+    let res = 0n;
+    for (let i = 0; i < 8; i++) {
+        res |= BigInt(buf[offset + i] ?? 0) << BigInt(8 * i);
+    }
+    return res;
+}
+function u128FromLE(buf, offset) {
+    let res = 0n;
+    for (let i = 0; i < 16; i++) {
+        res |= BigInt(buf[offset + i] ?? 0) << BigInt(8 * i);
+    }
+    return res;
+}
+// ---------------------------------------------------------------------------
+// Data fetching
+// ---------------------------------------------------------------------------
+async function fetchAllCustodies(connection) {
+    const addresses = CUSTODIES.map((c) => c.address);
+    const infos = await connection.getMultipleAccountsInfo(addresses, "confirmed");
+    return CUSTODIES.map((cfg, i) => {
+        const info = infos[i];
+        if (!info || !info.data) {
+            throw new Error(`No account data for custody ${cfg.name}`);
+        }
+        const data = info.data;
+        // Read target ratio — validated post-parse by checking sum ≈ 10000
+        const targetRatio = data.length >= OFFSET_TARGET_RATIO_BPS + 8
+            ? Number(u64FromLE(data, OFFSET_TARGET_RATIO_BPS))
+            : 0;
+        return {
+            cfg,
+            owned: u64FromLE(data, OFFSET_ASSETS_OWNED),
+            locked: u64FromLE(data, OFFSET_ASSETS_LOCKED),
+            guaranteedUsd: u64FromLE(data, OFFSET_ASSETS_GUARANTEED_USD),
+            globalShortSizes: u64FromLE(data, OFFSET_ASSETS_GLOBAL_SHORT_SIZES),
+            globalShortAveragePrices: u64FromLE(data, OFFSET_ASSETS_GLOBAL_SHORT_AVG_PX),
+            debt: u128FromLE(data, OFFSET_DEBT),
+            borrowLendInterestsAccrued: u128FromLE(data, OFFSET_BORROW_LEND_INTERESTS_ACCRUED),
+            targetRatioBps: targetRatio <= 10000 ? targetRatio : 0,
+        };
+    });
+}
+// Module-level memo for Jupiter price/v3 — 3 consumers in this file
+// (fetchJlpCustodyData, fetchJlpPoolDetails, fetchJlpEffectiveWeights) used to
+// each hit the API independently. A single jlp-pool-snapshot route would fire
+// 3 redundant calls per cache miss. 30s TTL is short enough that prices stay
+// fresh for downstream NAV/weight math, long enough to coalesce snapshot loads.
+const PRICES_TTL_MS = 30000;
+let pricesCache = null;
+let pricesInFlight = null;
+/**
+ * Reset the price memo. Intended for unit tests that mock global fetch with
+ * scenario-specific prices — module-level cache pollutes across tests when
+ * TTL has not expired, leading to assertion failures that depend on test
+ * ordering.
+ *
+ * Not part of the public surface for application code; cache TTL handles
+ * production. Exported under `__test__*` namespace convention so consumers
+ * tree-shake it out and never accidentally rely on cache invalidation.
+ */
+function __test__resetPricesCache() {
+    pricesCache = null;
+    pricesInFlight = null;
+}
+async function fetchPrices() {
+    if (pricesCache && Date.now() - pricesCache.at < PRICES_TTL_MS) {
+        return pricesCache.data;
+    }
+    if (pricesInFlight)
+        return pricesInFlight;
+    const ids = CUSTODIES.map((c) => c.mintAddress).join(",");
+    const url = `${JUPITER_PRICE_API}?ids=${ids}`;
+    pricesInFlight = (async () => {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Jupiter Price API error: ${response.status}`);
+            }
+            const json = (await response.json());
+            const prices = {};
+            for (const [mint, data] of Object.entries(json)) {
+                prices[mint] = data.usdPrice;
+            }
+            pricesCache = { at: Date.now(), data: prices };
+            return prices;
+        }
+        finally {
+            pricesInFlight = null;
+        }
+    })();
+    return pricesInFlight;
+}
+function calculateDebtTokens(raw) {
+    if (raw.debt <= raw.borrowLendInterestsAccrued)
+        return 0;
+    const netDebt = raw.debt - raw.borrowLendInterestsAccrued;
+    return Number(netDebt) / DEBT_MULTIPLIER / 10 ** raw.cfg.decimals;
+}
+function calculateCustodyAum(raw, priceUsd) {
+    const { cfg } = raw;
+    const tokScale = 10 ** cfg.decimals;
+    const ownedTokens = Number(raw.owned) / tokScale;
+    const lockedTokens = Number(raw.locked) / tokScale;
+    const debtTokens = calculateDebtTokens(raw);
+    const guaranteedUsd = Number(raw.guaranteedUsd) / SCALE_USD;
+    const shortSizeUsd = Number(raw.globalShortSizes) / SCALE_USD;
+    const shortAvgPxUsd = Number(raw.globalShortAveragePrices) / SCALE_USD;
+    // theoreticallyOwned = owned + debt (debt = lent-out tokens the pool still owns)
+    const theoreticallyOwned = ownedTokens + debtTokens;
+    const netAssetsTokens = Math.max(theoreticallyOwned - lockedTokens, 0);
+    const netAssetsUsd = netAssetsTokens * priceUsd;
+    // Short PnL from pool perspective (pool is counterparty)
+    let shortPnLUsd = 0;
+    if (shortSizeUsd > 0 && shortAvgPxUsd > 0 && priceUsd > 0) {
+        shortPnLUsd = (shortSizeUsd * (priceUsd - shortAvgPxUsd)) / shortAvgPxUsd;
+    }
+    let aumUsd = guaranteedUsd + netAssetsUsd + shortPnLUsd;
+    if (aumUsd < 0)
+        aumUsd = 0;
+    return {
+        name: cfg.name,
+        aumUsd,
+        weightBps: 0, // set in second pass
+        priceUsd,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Fetch JLP pool custody data and compute AUM breakdown with per-custody weights.
+ *
+ * Reads custody accounts on-chain and fetches prices from Jupiter's price API.
+ * Returns the total AUM in USD and per-custody breakdown including weight in basis points.
+ */
+// ---------------------------------------------------------------------------
+// Pool Account Fee Parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse Pool account to extract aumUsd (u128) using the dynamic offset logic
+ * from oracle.rs. Returns the offset just past aumUsd and the parsed value.
+ */
+function parsePoolAumUsd(data) {
+    if (data.length < 28)
+        return null;
+    let offset = 8; // skip discriminator
+    // Skip name string (4-byte len + utf8)
+    if (data.length < offset + 4)
+        return null;
+    const nameLen = data.readUInt32LE(offset);
+    if (nameLen > 64)
+        return null;
+    offset += 4 + nameLen;
+    // Skip custodies vec (4-byte len + Pubkey[])
+    if (data.length < offset + 4)
+        return null;
+    const custodiesLen = data.readUInt32LE(offset);
+    if (custodiesLen > 16)
+        return null;
+    offset += 4 + custodiesLen * 32;
+    // Read aumUsd (u128)
+    if (data.length < offset + 16)
+        return null;
+    const aumUsd = u128FromLE(data, offset);
+    offset += 16;
+    return { aumUsd, afterAumOffset: offset };
+}
+/**
+ * Try to parse the Fees struct from the Pool account data.
+ *
+ * After aumUsd, the Pool struct has a Limit struct followed by a Fees struct.
+ * The Limit struct size varies by program version, so we try multiple skip
+ * sizes and validate the parsed fee values.
+ *
+ * Fees layout (8 x u64):
+ *   [0] increasePositionBps
+ *   [1] decreasePositionBps
+ *   [2] addRemoveLiquidityBps
+ *   [3] swapBps
+ *   [4] taxBps
+ *   [5] stableSwapBps
+ *   [6] stableSwapTaxBps
+ *   [7] protocolShareBps
+ */
+function tryParsePoolFees(data, afterAumOffset) {
+    // Try different Limit struct sizes (2-5 u128 fields = 32-80 bytes)
+    for (const limitSize of [32, 48, 64, 80]) {
+        const feesStart = afterAumOffset + limitSize;
+        if (data.length < feesStart + 64)
+            continue;
+        const increasePos = Number(u64FromLE(data, feesStart));
+        const decreasePos = Number(u64FromLE(data, feesStart + 8));
+        const addRemLiq = Number(u64FromLE(data, feesStart + 16));
+        const swapBps = Number(u64FromLE(data, feesStart + 24));
+        const taxBps = Number(u64FromLE(data, feesStart + 32));
+        const stableSwap = Number(u64FromLE(data, feesStart + 40));
+        const stableSwapTax = Number(u64FromLE(data, feesStart + 48));
+        const protocolShare = Number(u64FromLE(data, feesStart + 56));
+        // All fee fields should be in [0, 1000] bps range
+        const allFees = [increasePos, decreasePos, addRemLiq, swapBps, taxBps,
+            stableSwap, stableSwapTax, protocolShare];
+        const allValid = allFees.every((f) => f >= 0 && f <= 1000);
+        // At least addRemLiq or swapBps should be non-zero
+        if (allValid && (addRemLiq > 0 || swapBps > 0)) {
+            return {
+                addRemoveLiquidityBps: addRemLiq,
+                swapBps,
+                taxBps,
+                stableSwapBps: stableSwap,
+                stableSwapTaxBps: stableSwapTax,
+            };
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Public: fetchJlpPoolDetails
+// ---------------------------------------------------------------------------
+/**
+ * Fetch full JLP pool details: fee parameters, per-custody target/current
+ * weights, pool AUM, and JLP price.
+ *
+ * Reads the Pool account for fees and aumUsd, Custody accounts for per-asset
+ * data including target weights, and the JLP mint for total supply.
+ */
+async function fetchJlpPoolDetails(connection) {
+    const poolAddress = constants_1.JLP_POOL_ACCOUNT;
+    const jlpMintAddress = constants_1.JLP_MINT;
+    const custodyAddresses = CUSTODIES.map((c) => c.address);
+    // Fetch Pool, JLP Mint, all Custodies, and prices in parallel
+    const [poolInfo, mintInfo, custodyInfos, pricesByMint] = await Promise.all([
+        connection.getAccountInfo(poolAddress, "confirmed"),
+        connection.getAccountInfo(jlpMintAddress, "confirmed"),
+        connection.getMultipleAccountsInfo(custodyAddresses, "confirmed"),
+        fetchPrices(),
+    ]);
+    // Parse Pool aumUsd
+    if (!poolInfo?.data)
+        throw new Error("Failed to fetch JLP Pool account");
+    const poolData = poolInfo.data;
+    const poolParsed = parsePoolAumUsd(poolData);
+    if (!poolParsed)
+        throw new Error("Failed to parse JLP Pool aumUsd");
+    // Parse Pool fees (best-effort — returns null if layout unknown)
+    const fees = tryParsePoolFees(poolData, poolParsed.afterAumOffset);
+    // Parse JLP supply from mint account (offset 36, u64)
+    if (!mintInfo?.data || mintInfo.data.length < 44)
+        throw new Error("Failed to fetch JLP mint");
+    const mintData = mintInfo.data;
+    const jlpSupplyRaw = u64FromLE(mintData, 36);
+    const jlpSupply = Number(jlpSupplyRaw) / 1e6; // JLP has 6 decimals
+    // Pool AUM in USD (u128 scaled to 6 decimals)
+    const poolAumUsd = Number(poolParsed.aumUsd) / SCALE_USD;
+    // JLP price
+    const jlpPrice = jlpSupply > 0 ? poolAumUsd / jlpSupply : 0;
+    // Parse custody data with prices
+    const prices = {};
+    for (const cfg of CUSTODIES) {
+        const p = pricesByMint[cfg.mintAddress];
+        prices[cfg.name] = p ?? (cfg.isStable ? 1 : 0);
+        if (!p && !cfg.isStable) {
+            throw new Error(`Missing price for ${cfg.name}`);
+        }
+    }
+    const parsedCustodies = CUSTODIES.map((cfg, i) => {
+        const info = custodyInfos[i];
+        if (!info?.data)
+            throw new Error(`No account data for custody ${cfg.name}`);
+        const data = info.data;
+        return {
+            cfg,
+            owned: u64FromLE(data, OFFSET_ASSETS_OWNED),
+            locked: u64FromLE(data, OFFSET_ASSETS_LOCKED),
+            guaranteedUsd: u64FromLE(data, OFFSET_ASSETS_GUARANTEED_USD),
+            globalShortSizes: u64FromLE(data, OFFSET_ASSETS_GLOBAL_SHORT_SIZES),
+            globalShortAveragePrices: u64FromLE(data, OFFSET_ASSETS_GLOBAL_SHORT_AVG_PX),
+            debt: u128FromLE(data, OFFSET_DEBT),
+            borrowLendInterestsAccrued: u128FromLE(data, OFFSET_BORROW_LEND_INTERESTS_ACCRUED),
+            targetRatioBps: data.length >= OFFSET_TARGET_RATIO_BPS + 8
+                ? Number(u64FromLE(data, OFFSET_TARGET_RATIO_BPS))
+                : 0,
+        };
+    });
+    // Compute per-custody AUM
+    const aumResults = parsedCustodies.map((raw) => calculateCustodyAum(raw, prices[raw.cfg.name] ?? 1));
+    const totalAum = aumResults.reduce((sum, r) => sum + r.aumUsd, 0);
+    // Validate target ratios — sum should be ~10000
+    const targetSum = parsedCustodies.reduce((sum, c) => sum + c.targetRatioBps, 0);
+    const targetRatiosValid = targetSum >= 9900 && targetSum <= 10100;
+    const custodies = parsedCustodies.map((raw, i) => ({
+        mint: new web3_js_1.PublicKey(raw.cfg.mintAddress),
+        name: raw.cfg.name,
+        targetRatioBps: targetRatiosValid ? raw.targetRatioBps : 0,
+        currentRatioBps: totalAum > 0 ? Math.round((aumResults[i].aumUsd / totalAum) * 10000) : 0,
+        aumUsd: aumResults[i].aumUsd,
+        isStable: raw.cfg.isStable,
+    }));
+    return { fees, custodies, poolAumUsd, jlpPrice, jlpSupply };
+}
+// ---------------------------------------------------------------------------
+// Public: computeAddLiquidityFee
+// ---------------------------------------------------------------------------
+/**
+ * Estimate the addLiquidity fee for depositing into a specific JLP custody.
+ *
+ * Implements the Jupiter Perps fee formula:
+ * - If deposit moves custody weight TOWARD target: rebate (fee < baseFee)
+ * - If deposit moves custody weight AWAY from target: tax (fee > baseFee)
+ *
+ * Formula:
+ *   initDiff = |currentRatio - targetRatio|
+ *   finalDiff = |newRatio - targetRatio|
+ *   avgDiff = (initDiff + finalDiff) / 2
+ *   if improving: fee = max(baseFee - taxBps * avgDiff / 10000, 0)
+ *   if worsening: fee = baseFee + taxBps * avgDiff / 10000
+ */
+function computeAddLiquidityFee(args) {
+    const { custodyAumUsd, poolAumUsd, targetRatioBps, depositUsd, fees, isStable } = args;
+    if (poolAumUsd <= 0 || targetRatioBps <= 0 || depositUsd <= 0) {
+        return { feeBps: fees.addRemoveLiquidityBps, isDiscount: false };
+    }
+    const baseFee = fees.addRemoveLiquidityBps;
+    const effectiveTaxBps = isStable ? fees.stableSwapTaxBps : fees.taxBps;
+    const currentRatio = (custodyAumUsd / poolAumUsd) * 10000;
+    const newCustodyAum = custodyAumUsd + depositUsd;
+    const newPoolAum = poolAumUsd + depositUsd;
+    const newRatio = (newCustodyAum / newPoolAum) * 10000;
+    const initDiff = Math.abs(currentRatio - targetRatioBps);
+    const finalDiff = Math.abs(newRatio - targetRatioBps);
+    const avgDiff = (initDiff + finalDiff) / 2;
+    if (finalDiff < initDiff) {
+        // Improving weight → rebate
+        const rebate = (effectiveTaxBps * avgDiff) / 10000;
+        return { feeBps: Math.max(baseFee - rebate, 0), isDiscount: true };
+    }
+    else {
+        // Worsening weight → penalty
+        const penalty = (effectiveTaxBps * avgDiff) / 10000;
+        return { feeBps: baseFee + penalty, isDiscount: false };
+    }
+}
+// ---------------------------------------------------------------------------
+// Public: fetchJlpCustodyData (existing)
+// ---------------------------------------------------------------------------
+async function fetchJlpCustodyData(connection) {
+    const [custodies, pricesByMint] = await Promise.all([
+        fetchAllCustodies(connection),
+        fetchPrices(),
+    ]);
+    // Build price lookup by custody name
+    const prices = {};
+    for (const cfg of CUSTODIES) {
+        const price = pricesByMint[cfg.mintAddress];
+        if (price === undefined || price === null) {
+            if (cfg.isStable) {
+                prices[cfg.name] = 1;
+            }
+            else {
+                throw new Error(`Missing price for non-stable asset ${cfg.name} (mint: ${cfg.mintAddress})`);
+            }
+        }
+        else {
+            prices[cfg.name] = price;
+        }
+    }
+    // Calculate per-custody AUM
+    const results = custodies.map((raw) => calculateCustodyAum(raw, prices[raw.cfg.name] ?? 1));
+    const totalAumUsd = results.reduce((sum, r) => sum + r.aumUsd, 0);
+    // Set weights in basis points
+    for (const r of results) {
+        r.weightBps = totalAumUsd > 0 ? Math.round((r.aumUsd / totalAumUsd) * 10000) : 0;
+    }
+    return {
+        timestamp: new Date().toISOString(),
+        totalAumUsd,
+        custodies: results,
+    };
+}
+/** Map JLP custody internal name to public symbol used by effective-weights API. */
+function toEffSymbol(name) {
+    return name === "WBTC" ? "BTC" : name;
+}
+/** Convert a float USD price to an 8-decimal-scaled bigint.
+ *
+ * Uses 12-decimal intermediate to preserve sub-1¢ precision before truncation. */
+function priceToScaled8(priceFloat) {
+    if (!isFinite(priceFloat) || priceFloat <= 0)
+        return 0n;
+    // Round to 12 decimals first to avoid float artifacts, then scale to 8.
+    const scaled12 = BigInt(Math.round(priceFloat * 1e12));
+    return scaled12 / 10000n; // 12 → 8 decimals
+}
+/** Compute effective USD (price-sensitivity-weighted) for a single custody.
+ *
+ * Formula (in 8-decimal USD):
+ *   netDebtTokens = max(debt − borrowLendInterestsAccrued, 0) / DEBT_MULTIPLIER
+ *   spot          = (owned + netDebtTokens − locked) × price_8dec / 10^decimals
+ *   short         = shortSize_6dec × price_8dec / avgShortPrice_6dec  (zeroed if either operand is 0)
+ *   effUsd        = max(spot, 0) + short
+ *
+ * Algebra for unit normalization:
+ *   - owned/locked/netDebt is in 10^decimals base units; price is 10^8 USD.
+ *     spot = (owned + netDebt − locked) × price_8dec / 10^decimals → 10^8 USD ✓
+ *   - debt is stored as u128 scaled by DEBT_MULTIPLIER (1e9) on top of 10^decimals.
+ *     netDebtTokens = (debt − borrowLendInterestsAccrued) / DEBT_MULTIPLIER
+ *     (integer division — small rounding under one base unit, acceptable).
+ *   - shortSize and avgShortPrice are both 10^6; ratio is dimensionless.
+ *     short = shortSize × price_8dec / avgShortPrice → 10^8 USD ✓
+ */
+function computeEffectiveUsd(input) {
+    const { owned, locked, debt, borrowLendInterestsAccrued, shortSizeUsd, avgShortPriceUsd, decimals, priceScaled8, } = input;
+    const tokScale = 10n ** BigInt(decimals);
+    // Net debt tokens: (debt − interestsAccrued) / DEBT_MULTIPLIER, clamped to 0.
+    // Matches `calculateDebtTokens` in `calculateCustodyAum` to keep both code paths
+    // consistent. DEBT_MULTIPLIER is 1e9, scaled before token decimals.
+    const DEBT_MULTIPLIER_BIG = 1000000000n; // 1e9, matches DEBT_MULTIPLIER constant
+    let netDebtTokens = 0n;
+    if (debt > borrowLendInterestsAccrued) {
+        netDebtTokens = (debt - borrowLendInterestsAccrued) / DEBT_MULTIPLIER_BIG;
+    }
+    // Spot term: (owned + netDebt − locked) × price / 10^decimals
+    // Use signed bigint subtraction; clamp to 0 if (owned + netDebt) < locked.
+    const netTokens = owned + netDebtTokens - locked; // bigint — can go negative
+    let spotEffUsd;
+    let spotClamped = false;
+    if (netTokens <= 0n) {
+        spotEffUsd = 0n;
+        if (netTokens < 0n)
+            spotClamped = true;
+    }
+    else {
+        spotEffUsd = (netTokens * priceScaled8) / tokScale;
+    }
+    // Short term: only contributes when both shortSize and avgShortPrice > 0.
+    // Numerator stays in u128 range comfortably (shortSize_6dec × price_8dec).
+    let shortEffUsd = 0n;
+    if (shortSizeUsd > 0n && avgShortPriceUsd > 0n && priceScaled8 > 0n) {
+        shortEffUsd = (shortSizeUsd * priceScaled8) / avgShortPriceUsd;
+    }
+    return {
+        spotEffUsd,
+        shortEffUsd,
+        effUsd: spotEffUsd + shortEffUsd,
+        spotClamped,
+        netDebtTokens,
+    };
+}
+/** Compute basis-point shares for each effective USD value, summing to 10000.
+ *
+ * Uses largest-remainder allocation to guarantee the bps sum equals exactly 10000
+ * even with rounding. (Naive `round(eff_i / total × 10000)` per-asset can drift
+ * by up to `n` bps cumulatively.) Returns 0s for all assets if total is 0.
+ */
+function computeBpsShares(effs) {
+    const total = effs.reduce((s, e) => s + e, 0n);
+    if (total === 0n)
+        return effs.map(() => 0);
+    // Floor allocation
+    const exact = effs.map((e) => Number((e * 10000n) / total));
+    const allocated = exact.reduce((s, b) => s + b, 0);
+    let remaining = 10000 - allocated;
+    if (remaining <= 0)
+        return exact;
+    // Distribute remaining bps to the assets with largest fractional remainders.
+    // Compute remainder = (e × 10000) mod total, ranked descending.
+    const remainders = effs.map((e, i) => ({
+        i,
+        rem: (e * 10000n) % total,
+    }));
+    remainders.sort((a, b) => (a.rem === b.rem ? 0 : a.rem > b.rem ? -1 : 1));
+    const result = exact.slice();
+    for (let k = 0; k < remainders.length && remaining > 0; k++) {
+        result[remainders[k].i]++;
+        remaining--;
+    }
+    return result;
+}
+/**
+ * Fetch JLP pool effective-weight composition.
+ *
+ * Returns price-sensitivity-weighted shares per asset, dropping `guaranteed_usd`
+ * from the per-asset weight calculation. Suitable for rebalance planners that
+ * want to track the pool's true delta-1 composition rather than reported aumUsd.
+ *
+ * Reuses the same on-chain custody parser and Jupiter Price API source as
+ * `fetchJlpCustodyData` to keep numbers consistent across callers.
+ *
+ * @returns assets in fixed order: BTC, ETH, SOL, USDC, USDT.
+ */
+async function fetchJlpEffectiveWeights(connection) {
+    const [custodies, pricesByMint] = await Promise.all([
+        fetchAllCustodies(connection),
+        fetchPrices(),
+    ]);
+    // Resolve price per custody (stables fall back to $1.00 when API is missing them).
+    const priceFloat = {};
+    for (const cfg of CUSTODIES) {
+        const p = pricesByMint[cfg.mintAddress];
+        if (p === undefined || p === null) {
+            if (cfg.isStable) {
+                priceFloat[cfg.name] = 1;
+            }
+            else {
+                throw new Error(`Missing price for non-stable asset ${cfg.name} (mint: ${cfg.mintAddress})`);
+            }
+        }
+        else {
+            priceFloat[cfg.name] = p;
+        }
+    }
+    // Compute effective USD per custody.
+    const computed = custodies.map((raw) => {
+        const effInput = {
+            owned: raw.owned,
+            locked: raw.locked,
+            debt: raw.debt,
+            borrowLendInterestsAccrued: raw.borrowLendInterestsAccrued,
+            shortSizeUsd: raw.globalShortSizes,
+            avgShortPriceUsd: raw.globalShortAveragePrices,
+            guaranteedUsd: raw.guaranteedUsd,
+            decimals: raw.cfg.decimals,
+            priceScaled8: priceToScaled8(priceFloat[raw.cfg.name]),
+        };
+        return { raw, out: computeEffectiveUsd(effInput) };
+    });
+    const effs = computed.map((c) => c.out.effUsd);
+    const bpsShares = computeBpsShares(effs);
+    const assets = computed.map((c, i) => ({
+        mint: new web3_js_1.PublicKey(c.raw.cfg.mintAddress),
+        symbol: toEffSymbol(c.raw.cfg.name),
+        effUsd: c.out.effUsd,
+        effShareBps: bpsShares[i],
+        spotClamped: c.out.spotClamped,
+    }));
+    const totalEffUsd = effs.reduce((s, e) => s + e, 0n);
+    // Total pool aumUsd in 8-decimal USD = aumUsd from `calculateCustodyAum` (float)
+    // re-aggregated. We reuse the existing path but normalize to bigint 8-decimals.
+    // Each calculateCustodyAum return is a float USD; multiply by 1e8 and round.
+    const totalAumFloat = custodies.reduce((sum, raw) => {
+        const a = calculateCustodyAum(raw, priceFloat[raw.cfg.name] ?? 1);
+        return sum + a.aumUsd;
+    }, 0);
+    const totalAumUsd = BigInt(Math.round(totalAumFloat * 1e8));
+    return { assets, totalEffUsd, totalAumUsd };
+}