@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/jlpd-strategy/jupusd-earn.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Jupiter Lend Earn SDK helpers for JLPD Strategy.
+ *
+ * Provides position reading and APR computation for the JupUSD Earn
+ * pool used by the JLP Borrow / JupUSD Earn route.
+ *
+ * Reuses the JupUSD pool config from elemental-lend/jupiter-lend.ts
+ * since it's the same Jupiter Lend Earn program and pool.
+ *
+ * @remarks
+ * Read-only utilities for displaying JupUSD Earn positions. This module exports
+ * **no instruction builders** — all on-chain operations against the Jupiter
+ * Lend Earn program are routed through `adapter.ts`. The exports here are:
+ *
+ *   - Static program / account constants for the JupUSD Earn pool
+ *   - `computeExchangeRate`, `computeFTokenValue`, `computeEarnApr` — math
+ *   - `fetchEarnPosition` — read-only position fetcher
+ *
+ * Anything new that needs to *send transactions* should live in `adapter.ts`.
+ */
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import type { SolanaConnection } from "../common/connection";
+import { JUP_LEND_EARN_PROGRAM } from "../elemental-lend/constants";
+/**
+ * Jupiter Lend Earn program ID. Re-exported from `elemental-lend/constants`
+ * so callers of `jlpd-strategy/jupusd-earn` can reach it without an extra
+ * import path.
+ */
+export { JUP_LEND_EARN_PROGRAM };
+export declare const JUPUSD_LENDING: PublicKey;
+export declare const JUPUSD_FTOKEN_MINT: PublicKey;
+export declare const JUPUSD_RESERVES_LIQUIDITY: PublicKey;
+export declare const JUPUSD_SUPPLY_POS_ON_LIQ: PublicKey;
+export declare const JUPUSD_RATE_MODEL: PublicKey;
+export declare const JUPUSD_VAULT: PublicKey;
+export declare const JUPUSD_REWARDS_RATE_MODEL: PublicKey;
+export declare const JUPUSD_LENDING_ADMIN: PublicKey;
+/**
+ * Read the earn exchange rate from lending account + rewards model.
+ * Returns the rate scaled to 1e12.
+ *
+ * Jupiter Lend Earn lending account layout (relevant fields):
+ *   [115..123]  baseExchangePrice    u64   (1e12 precision)
+ *   [123..131]  lastUpdate            u64   (unix seconds)
+ *
+ * Jupiter Lend rewards rate model layout (relevant fields):
+ *   [ 56.. 64]  startTime             u64   (unix seconds)
+ *   [ 64.. 72]  yearlyReward          u64   (rewards distributed per year)
+ */
+export declare function computeExchangeRate(lendingData: Buffer, rewardsModelData: Buffer, fTokenTotalSupply: BN, currentTimestamp: number): bigint;
+/**
+ * Compute the value of fTokens in JupUSD (native 6-decimal).
+ */
+export declare function computeFTokenValue(fTokenBalance: BN, exchangeRate: bigint): BN;
+export interface EarnAprBreakdown {
+    lendingApr: number;
+    rewardsApr: number;
+    totalApr: number;
+}
+/**
+ * Compute earn APR breakdown: base lending + rewards.
+ *
+ * Total APR is derived by projecting the exchange rate 1 year forward
+ * (captures both lending yield and rewards). Rewards APR is isolated
+ * from yearly_reward / total_assets. Base = total - rewards.
+ */
+/**
+ * Compute earn APR breakdown: base lending + rewards.
+ *
+ * Reads the liquidity pool's supply rate from the liquidity account,
+ * and the rewards rate from the rewards model. Requires the liquidity
+ * account data as an additional parameter.
+ *
+ * @param rewardsModelData - Rewards rate model account data
+ * @param fTokenTotalSupply - fToken total supply (from mint)
+ * @param tokenExchangePrice - From lending account offset 115
+ * @param liquiditySupplyRate - Supply rate from liquidity pool (pass 0 if unknown)
+ */
+export declare function computeEarnApr(rewardsModelData: Buffer, fTokenTotalSupply: BN, tokenExchangePrice: bigint, liquiditySupplyRate?: number): EarnAprBreakdown;
+export interface EarnPositionInfo {
+    fTokenBalance: BN;
+    jupusdValue: BN;
+    apr: EarnAprBreakdown;
+}
+/**
+ * Fetch the earn position for a jlpd_config PDA.
+ * Returns null if no fToken ATA exists.
+ */
+export declare function fetchEarnPosition(connection: SolanaConnection, fTokenAta: PublicKey): Promise<EarnPositionInfo | null>;

package/dist/jlpd-strategy/jupusd-earn.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Jupiter Lend Earn SDK helpers for JLPD Strategy.
+ *
+ * Provides position reading and APR computation for the JupUSD Earn
+ * pool used by the JLP Borrow / JupUSD Earn route.
+ *
+ * Reuses the JupUSD pool config from elemental-lend/jupiter-lend.ts
+ * since it's the same Jupiter Lend Earn program and pool.
+ *
+ * @remarks
+ * Read-only utilities for displaying JupUSD Earn positions. This module exports
+ * **no instruction builders** — all on-chain operations against the Jupiter
+ * Lend Earn program are routed through `adapter.ts`. The exports here are:
+ *
+ *   - Static program / account constants for the JupUSD Earn pool
+ *   - `computeExchangeRate`, `computeFTokenValue`, `computeEarnApr` — math
+ *   - `fetchEarnPosition` — read-only position fetcher
+ *
+ * Anything new that needs to *send transactions* should live in `adapter.ts`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JUPUSD_LENDING_ADMIN = exports.JUPUSD_REWARDS_RATE_MODEL = exports.JUPUSD_VAULT = exports.JUPUSD_RATE_MODEL = exports.JUPUSD_SUPPLY_POS_ON_LIQ = exports.JUPUSD_RESERVES_LIQUIDITY = exports.JUPUSD_FTOKEN_MINT = exports.JUPUSD_LENDING = exports.JUP_LEND_EARN_PROGRAM = void 0;
+exports.computeExchangeRate = computeExchangeRate;
+exports.computeFTokenValue = computeFTokenValue;
+exports.computeEarnApr = computeEarnApr;
+exports.fetchEarnPosition = fetchEarnPosition;
+const bn_js_1 = __importDefault(require("bn.js"));
+const buffer_1 = require("../common/buffer");
+const jupiter_lend_1 = require("../elemental-lend/jupiter-lend");
+const constants_1 = require("../elemental-lend/constants");
+Object.defineProperty(exports, "JUP_LEND_EARN_PROGRAM", { enumerable: true, get: function () { return constants_1.JUP_LEND_EARN_PROGRAM; } });
+// ============================================================================
+// JupUSD Earn Pool — Static Accounts
+// ----------------------------------------------------------------------------
+// All pool addresses are imported from `elemental-lend/jupiter-lend.ts` so
+// there is exactly one canonical definition. The named re-exports below are
+// preserved for backwards compatibility with any external consumers.
+// ============================================================================
+exports.JUPUSD_LENDING = jupiter_lend_1.JUPUSD_POOL.lending;
+exports.JUPUSD_FTOKEN_MINT = jupiter_lend_1.JUPUSD_POOL.fTokenMint;
+exports.JUPUSD_RESERVES_LIQUIDITY = jupiter_lend_1.JUPUSD_POOL.tokenReservesLiquidity;
+exports.JUPUSD_SUPPLY_POS_ON_LIQ = jupiter_lend_1.JUPUSD_POOL.supplyPositionOnLiquidity;
+exports.JUPUSD_RATE_MODEL = jupiter_lend_1.JUPUSD_POOL.rateModel;
+exports.JUPUSD_VAULT = jupiter_lend_1.JUPUSD_POOL.vault;
+exports.JUPUSD_REWARDS_RATE_MODEL = jupiter_lend_1.JUPUSD_POOL.rewardsRateModel;
+exports.JUPUSD_LENDING_ADMIN = jupiter_lend_1.LENDING_ADMIN;
+// ============================================================================
+// Exchange Rate / APR Computation
+// ============================================================================
+const EXCHANGE_PRICES_PRECISION = 1000000000000n; // 1e12
+const SECONDS_PER_YEAR = 31536000;
+/**
+ * Read the earn exchange rate from lending account + rewards model.
+ * Returns the rate scaled to 1e12.
+ *
+ * Jupiter Lend Earn lending account layout (relevant fields):
+ *   [115..123]  baseExchangePrice    u64   (1e12 precision)
+ *   [123..131]  lastUpdate            u64   (unix seconds)
+ *
+ * Jupiter Lend rewards rate model layout (relevant fields):
+ *   [ 56.. 64]  startTime             u64   (unix seconds)
+ *   [ 64.. 72]  yearlyReward          u64   (rewards distributed per year)
+ */
+function computeExchangeRate(lendingData, rewardsModelData, fTokenTotalSupply, currentTimestamp) {
+    if (lendingData.length < 131)
+        throw new Error("Lending data too short");
+    const baseRate = (0, buffer_1.readU64)(lendingData, 115).toNumber();
+    const lastUpdate = (0, buffer_1.readU64)(lendingData, 123).toNumber();
+    if (rewardsModelData.length < 72)
+        return BigInt(baseRate);
+    const startTime = (0, buffer_1.readU64)(rewardsModelData, 56).toNumber();
+    const yearlyReward = (0, buffer_1.readU64)(rewardsModelData, 64).toNumber();
+    if (yearlyReward === 0 || fTokenTotalSupply.isZero())
+        return BigInt(baseRate);
+    // Compute time-accrued rewards since last update
+    const elapsed = Math.max(0, currentTimestamp - Math.max(lastUpdate, startTime));
+    const totalAssets = Number((BigInt(fTokenTotalSupply.toString()) * BigInt(baseRate)) / EXCHANGE_PRICES_PRECISION);
+    if (totalAssets === 0)
+        return BigInt(baseRate);
+    // rewards_return = yearly_reward * elapsed / SECONDS_PER_YEAR / total_assets
+    // new_rate = base_rate + base_rate * rewards_return / 1e14
+    const rewardAmount = (yearlyReward * elapsed) / SECONDS_PER_YEAR;
+    const rewardsReturn = Math.floor((rewardAmount * 1e14) / totalAssets);
+    const newRate = BigInt(baseRate) + (BigInt(baseRate) * BigInt(rewardsReturn)) / 100000000000000n;
+    return newRate;
+}
+/**
+ * Compute the value of fTokens in JupUSD (native 6-decimal).
+ */
+function computeFTokenValue(fTokenBalance, exchangeRate) {
+    const value = (BigInt(fTokenBalance.toString()) * exchangeRate) / EXCHANGE_PRICES_PRECISION;
+    return new bn_js_1.default(value.toString());
+}
+/**
+ * Compute earn APR breakdown: base lending + rewards.
+ *
+ * Total APR is derived by projecting the exchange rate 1 year forward
+ * (captures both lending yield and rewards). Rewards APR is isolated
+ * from yearly_reward / total_assets. Base = total - rewards.
+ */
+/**
+ * Compute earn APR breakdown: base lending + rewards.
+ *
+ * Reads the liquidity pool's supply rate from the liquidity account,
+ * and the rewards rate from the rewards model. Requires the liquidity
+ * account data as an additional parameter.
+ *
+ * @param rewardsModelData - Rewards rate model account data
+ * @param fTokenTotalSupply - fToken total supply (from mint)
+ * @param tokenExchangePrice - From lending account offset 115
+ * @param liquiditySupplyRate - Supply rate from liquidity pool (pass 0 if unknown)
+ */
+function computeEarnApr(rewardsModelData, fTokenTotalSupply, tokenExchangePrice, liquiditySupplyRate) {
+    const zero = { lendingApr: 0, rewardsApr: 0, totalApr: 0 };
+    if (rewardsModelData.length < 72)
+        return zero;
+    if (fTokenTotalSupply.isZero() || tokenExchangePrice === 0n)
+        return zero;
+    // Rewards APR: yearly_reward / total_assets * 100
+    const yearlyReward = Number((0, buffer_1.readU64)(rewardsModelData, 64).toString());
+    const totalAssets = Number(BigInt(fTokenTotalSupply.toString()) * tokenExchangePrice / EXCHANGE_PRICES_PRECISION);
+    const rewardsApr = totalAssets > 0 ? (yearlyReward / totalAssets) * 100 : 0;
+    // Lending APR: from liquidity pool supply rate if provided
+    // The lend-read SDK returns supplyRate as an integer where /100 = %
+    const lendingApr = liquiditySupplyRate != null ? liquiditySupplyRate / 100 : 0;
+    return {
+        lendingApr,
+        rewardsApr,
+        totalApr: lendingApr + rewardsApr,
+    };
+}
+/**
+ * Fetch the earn position for a jlpd_config PDA.
+ * Returns null if no fToken ATA exists.
+ */
+async function fetchEarnPosition(connection, fTokenAta) {
+    const [ataInfo, lendingInfo, rewardsInfo, mintInfo] = await connection.getMultipleAccountsInfo([
+        fTokenAta,
+        exports.JUPUSD_LENDING,
+        exports.JUPUSD_REWARDS_RATE_MODEL,
+        exports.JUPUSD_FTOKEN_MINT,
+    ]);
+    if (!ataInfo || !lendingInfo || !rewardsInfo || !mintInfo)
+        return null;
+    // SPL Token Account layout: [mint(0..32)][owner(32..64)][amount(64..72)]…
+    const ataData = ataInfo.data;
+    if (ataData.length < 72)
+        return null;
+    const fTokenBalance = (0, buffer_1.readU64)(ataData, 64);
+    // SPL Token Mint layout: [mintAuthority(0..36)][supply(36..44)][decimals(44..45)]…
+    const mintData = mintInfo.data;
+    const fTokenSupply = (0, buffer_1.readU64)(mintData, 36);
+    // baseExchangePrice from Jupiter Lend Earn lending account (offset 115)
+    const lendingData = lendingInfo.data;
+    const rewardsData = rewardsInfo.data;
+    const tokenExchangePrice = BigInt((0, buffer_1.readU64)(lendingData, 115).toString());
+    const now = Math.floor(Date.now() / 1000);
+    const exchangeRate = computeExchangeRate(lendingData, rewardsData, fTokenSupply, now);
+    const jupusdValue = computeFTokenValue(fTokenBalance, exchangeRate);
+    const apr = computeEarnApr(rewardsData, fTokenSupply, tokenExchangePrice);
+    return { fTokenBalance, jupusdValue, apr };
+}

package/dist/jlpd-strategy/live-jlp-price.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Live per-custody JLP price — canonical SDK port of the on-chain
+ * `jlpd-strategy/programs/jlpd-strategy/src/utils/oracle.rs::compute_live_jlp_price`
+ * (program `GXqt4ZH2UUBsLWwMNJiZMXza3q7xEGChfW8XjVRjLxr5`, mainnet). Verbatim port of
+ * `jlpd-server/src/services/live-jlp-price.ts` (itself a verified mirror of `oracle.rs`) —
+ * promoted here per the on-chain-strategy-migration plan so BOTH the strategy driver and the
+ * frontend consume ONE typed implementation instead of jlpd-server's private copy.
+ *
+ * This recomputes JLP's virtual price directly from the Jupiter Perps pool's `custodies` Vec +
+ * each custody account's own balances/debt/short state, instead of trusting the pool's stored
+ * `aumUsd` snapshot (see `readJlpPoolPrice`-style helpers in `jlp-data.ts` for that older path).
+ * Only the on-chain `settle_yield` path uses this live recompute; this module exists so a
+ * driver/frontend can predict it off-chain before submitting a tx, or simply render it.
+ *
+ * ALL arithmetic is bigint to match Rust's u128/i128 exactly (truncating division for the
+ * signed short-PnL term; ceil-division for net_debt).
+ *
+ * The custody SET, count, and order come ENTIRELY from the pool's own `custodies` Vec
+ * (`getPoolCustodyPubkeys`) — nothing about the custody list is hardcoded here. The only pinned
+ * mapping is volatile mint -> Doves feed (SOL/ETH/WBTC); an unrecognized volatile mint fails
+ * closed.
+ */
+import { PublicKey } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+/**
+ * Parse a Doves oracle price-feed account into an 8-decimal price. Mirrors
+ * `oracle.rs::read_doves_price`'s parse (price@73 u64, exponent@81 i8) minus the
+ * owner/tag/staleness checks, which the on-chain program alone enforces on ITS reads — this
+ * helper is a pure parse for off-chain prediction/rendering.
+ */
+export declare function parseDovesPrice(data: Buffer): bigint;
+/**
+ * Parse the JLP pool account's `custodies` Vec and return the custody pubkeys IN VEC ORDER.
+ * This is the sole source of truth for the custody set/count/order — nothing is hardcoded.
+ */
+export declare function getPoolCustodyPubkeys(connection: SolanaConnection): Promise<PublicKey[]>;
+/**
+ * Live JLP price (8-dec) = Σ per-custody USD × 1e8 / jlp_supply.
+ *
+ * Mirrors `compute_live_jlp_price` exactly: reads the pool's custody Vec (order + count from
+ * the pool itself, nothing hardcoded), decodes + guards each custody, prices volatiles off
+ * Doves ([SOL, ETH, BTC]), values stables at $1, sums, requires
+ * Σtarget_ratio_bps == 10000 (layout tripwire), divides by live JLP mint supply, and clamps to
+ * [$0.50, $50].
+ */
+export declare function computeLiveJlpPriceUsd(connection: SolanaConnection): Promise<bigint>;

package/dist/jlpd-strategy/live-jlp-price.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * Live per-custody JLP price — canonical SDK port of the on-chain
+ * `jlpd-strategy/programs/jlpd-strategy/src/utils/oracle.rs::compute_live_jlp_price`
+ * (program `GXqt4ZH2UUBsLWwMNJiZMXza3q7xEGChfW8XjVRjLxr5`, mainnet). Verbatim port of
+ * `jlpd-server/src/services/live-jlp-price.ts` (itself a verified mirror of `oracle.rs`) —
+ * promoted here per the on-chain-strategy-migration plan so BOTH the strategy driver and the
+ * frontend consume ONE typed implementation instead of jlpd-server's private copy.
+ *
+ * This recomputes JLP's virtual price directly from the Jupiter Perps pool's `custodies` Vec +
+ * each custody account's own balances/debt/short state, instead of trusting the pool's stored
+ * `aumUsd` snapshot (see `readJlpPoolPrice`-style helpers in `jlp-data.ts` for that older path).
+ * Only the on-chain `settle_yield` path uses this live recompute; this module exists so a
+ * driver/frontend can predict it off-chain before submitting a tx, or simply render it.
+ *
+ * ALL arithmetic is bigint to match Rust's u128/i128 exactly (truncating division for the
+ * signed short-PnL term; ceil-division for net_debt).
+ *
+ * The custody SET, count, and order come ENTIRELY from the pool's own `custodies` Vec
+ * (`getPoolCustodyPubkeys`) — nothing about the custody list is hardcoded here. The only pinned
+ * mapping is volatile mint -> Doves feed (SOL/ETH/WBTC); an unrecognized volatile mint fails
+ * closed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDovesPrice = parseDovesPrice;
+exports.getPoolCustodyPubkeys = getPoolCustodyPubkeys;
+exports.computeLiveJlpPriceUsd = computeLiveJlpPriceUsd;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+// ============================================================================
+// Constants (mirrors oracle.rs's top-of-file constants + CUST_* offsets)
+// ============================================================================
+/** Anchor discriminator of the Jupiter Perps `Pool` account: sha256("account:Pool")[..8]. */
+const JLP_POOL_DISCRIMINATOR = Buffer.from([0xf1, 0x9a, 0x6d, 0x04, 0x11, 0xb1, 0x6d, 0xbc]);
+/** Jupiter Perps `Custody` Anchor discriminator: sha256("account:Custody")[..8]. */
+const JLP_CUSTODY_DISCRIMINATOR = Buffer.from([0x01, 0xb8, 0x30, 0x51, 0x5d, 0x83, 0x3f, 0x91]);
+/** Upper bound on the pool custody count (currently 6). Bounds the Vec walk. */
+const MAX_JLP_CUSTODIES = 16;
+/** Custody `targetRatioBps` must sum to exactly 100% (layout tripwire). */
+const TARGET_RATIO_BPS_SUM = 10000n;
+/** Hardcoded stablecoin price: $1 USD with 8 decimals. */
+const STABLECOIN_PRICE_USD = 100000000n;
+/** on-chain `debt`/`bli` are scaled by 1e9. */
+const DEBT_DIVISOR = 1000000000n;
+/** Price clamp: [$0.50, $50] (8-dec). Out of range → fail closed. */
+const MIN_JLP_PRICE = 50000000n;
+const MAX_JLP_PRICE = 5000000000n;
+// Jupiter Perps `Custody` field offsets (mirrors oracle.rs's CUST_* constants).
+const CUST_POOL = 8; // Pubkey — must == JLP_POOL_ACCOUNT
+const CUST_MINT = 40; // Pubkey
+const CUST_DECIMALS = 104; // u8
+const CUST_IS_STABLE = 105; // bool
+const CUST_TARGET_RATIO_BPS = 206; // u64
+const CUST_OWNED = 222; // u64 (token native)
+const CUST_LOCKED = 230; // u64
+const CUST_GUARANTEED_USD = 238; // u64 (USD 1e6)
+const CUST_GLOBAL_SHORT_SIZES = 246; // u64 (USD 1e6)
+const CUST_GLOBAL_SHORT_AVG_PX = 254; // u64 (USD 1e6)
+const CUST_DEBT = 1004; // u128
+const CUST_BLI = 1020; // u128 (borrowLendInterestsAccrued)
+const CUST_MIN_LEN = 1036; // must cover through BLI (u128 @ 1020..1036)
+// ============================================================================
+// Binary parsing helpers
+// ============================================================================
+function readU128LE(buf, offset) {
+    let res = 0n;
+    for (let i = 0; i < 16; i++) {
+        res |= BigInt(buf[offset + i] ?? 0) << BigInt(8 * i);
+    }
+    return res;
+}
+function readPubkeyAt(buf, offset) {
+    return new web3_js_1.PublicKey(buf.subarray(offset, offset + 32));
+}
+/**
+ * Parse a Doves oracle price-feed account into an 8-decimal price. Mirrors
+ * `oracle.rs::read_doves_price`'s parse (price@73 u64, exponent@81 i8) minus the
+ * owner/tag/staleness checks, which the on-chain program alone enforces on ITS reads — this
+ * helper is a pure parse for off-chain prediction/rendering.
+ */
+function parseDovesPrice(data) {
+    if (data.length < 91)
+        throw new Error("live-jlp-price: Doves oracle data too short");
+    const rawPrice = data.readBigUInt64LE(73);
+    const exponent = (data[81] << 24) >> 24; // sign-extend i8
+    const expDiff = 8 + exponent;
+    return expDiff >= 0
+        ? rawPrice * 10n ** BigInt(expDiff)
+        : rawPrice / 10n ** BigInt(-expDiff);
+}
+// ============================================================================
+// Pool custodies Vec parse
+// ============================================================================
+/**
+ * Parse the JLP pool account's `custodies` Vec and return the custody pubkeys IN VEC ORDER.
+ * This is the sole source of truth for the custody set/count/order — nothing is hardcoded.
+ */
+async function getPoolCustodyPubkeys(connection) {
+    const poolInfo = await connection.getAccountInfo(constants_1.JLP_POOL_ACCOUNT);
+    if (!poolInfo)
+        throw new Error("live-jlp-price: JLP pool account not found");
+    if (!poolInfo.owner.equals(constants_1.JUPITER_PERPS_PROGRAM)) {
+        throw new Error("live-jlp-price: JLP pool account owned by unexpected program");
+    }
+    const data = poolInfo.data;
+    if (data.length < 12)
+        throw new Error("live-jlp-price: JLP pool account too short");
+    if (!data.subarray(0, 8).equals(JLP_POOL_DISCRIMINATOR)) {
+        throw new Error("live-jlp-price: JLP pool discriminator mismatch (layout changed?)");
+    }
+    const nameLen = data.readUInt32LE(8);
+    if (nameLen > 64)
+        throw new Error(`live-jlp-price: JLP pool name length implausible: ${nameLen}`);
+    const countOff = 12 + nameLen;
+    if (data.length < countOff + 4)
+        throw new Error("live-jlp-price: JLP pool account too short (custodies count)");
+    const count = data.readUInt32LE(countOff);
+    if (count < 1 || count > MAX_JLP_CUSTODIES) {
+        throw new Error(`live-jlp-price: JLP pool custody count implausible: ${count}`);
+    }
+    const pkStart = countOff + 4;
+    if (data.length < pkStart + count * 32) {
+        throw new Error("live-jlp-price: JLP pool account too short (custodies pubkeys)");
+    }
+    const pubkeys = [];
+    for (let i = 0; i < count; i++) {
+        pubkeys.push(readPubkeyAt(data, pkStart + i * 32));
+    }
+    return pubkeys;
+}
+/** Decode + guard one custody account's raw bytes. Throws on any binding mismatch. */
+function decodeCustodyBytes(data, owner) {
+    if (!owner.equals(constants_1.JUPITER_PERPS_PROGRAM)) {
+        throw new Error("live-jlp-price: custody account owned by unexpected program");
+    }
+    if (data.length < CUST_MIN_LEN)
+        throw new Error("live-jlp-price: custody account too short");
+    if (!data.subarray(0, 8).equals(JLP_CUSTODY_DISCRIMINATOR)) {
+        throw new Error("live-jlp-price: custody discriminator mismatch (layout changed?)");
+    }
+    if (!readPubkeyAt(data, CUST_POOL).equals(constants_1.JLP_POOL_ACCOUNT)) {
+        throw new Error("live-jlp-price: custody pool binding mismatch");
+    }
+    const debt = readU128LE(data, CUST_DEBT);
+    const bli = readU128LE(data, CUST_BLI);
+    // net_debt = ceil((debt - bli) / 1e9) — matches Jupiter's div_ceil (Rust saturating_sub + ceil-div).
+    const satSub = debt > bli ? debt - bli : 0n;
+    const netDebt = (satSub + DEBT_DIVISOR - 1n) / DEBT_DIVISOR;
+    return {
+        isStable: data[CUST_IS_STABLE] !== 0,
+        decimals: data[CUST_DECIMALS],
+        mint: readPubkeyAt(data, CUST_MINT),
+        owned: data.readBigUInt64LE(CUST_OWNED),
+        locked: data.readBigUInt64LE(CUST_LOCKED),
+        guaranteedUsd: data.readBigUInt64LE(CUST_GUARANTEED_USD),
+        shortSizes: data.readBigUInt64LE(CUST_GLOBAL_SHORT_SIZES),
+        shortAvgPx: data.readBigUInt64LE(CUST_GLOBAL_SHORT_AVG_PX),
+        netDebt,
+        targetRatioBps: data.readBigUInt64LE(CUST_TARGET_RATIO_BPS),
+    };
+}
+/** amount * price / 10^(decimals + 8 - 6), or amount * price * 10^-(...) if negative exponent. */
+function baseToUsdU128(amount, price, decimals) {
+    if (amount === 0n || price === 0n)
+        return 0n;
+    const num = amount * price;
+    const exponent = decimals + 8 - 6; // ORACLE_PRICE_DECIMALS - USD_DECIMALS
+    if (exponent >= 0) {
+        return num / 10n ** BigInt(exponent);
+    }
+    return num * 10n ** BigInt(-exponent);
+}
+/** Map a VOLATILE custody's mint to its `vol_prices` index ([SOL, ETH, BTC]). Unknown volatile → throw. */
+function volatileDovesIndex(mint) {
+    if (mint.equals(constants_1.MINT_WSOL))
+        return 0;
+    if (mint.equals(constants_1.MINT_WETH))
+        return 1;
+    if (mint.equals(constants_1.MINT_WBTC))
+        return 2;
+    throw new Error(`live-jlp-price: unrecognized volatile custody mint ${mint.toBase58()} (no oracle feed)`);
+}
+/** Per-custody USD (6-dec). `price` is the volatile Doves price (8-dec); ignored for stables. */
+function custodyUsd(c, price) {
+    const net = c.owned + c.netDebt;
+    if (c.isStable) {
+        // Stable: (owned + net_debt) * $1. No locked / guaranteed / short.
+        return baseToUsdU128(net, STABLECOIN_PRICE_USD, c.decimals);
+    }
+    // Volatile: max( spot + guaranteedUsd + signedShortPnL, 0 )
+    const spot = net <= c.locked ? 0n : baseToUsdU128(net - c.locked, price, c.decimals);
+    // shortPnL = shortSizes * (price/100 - avgShortPx) / avgShortPx — SIGNED, USD 1e6.
+    // Doves price is 8-dec; /100 rescales to the 6-dec avgShortPx basis.
+    let short = 0n;
+    if (c.shortSizes > 0n && c.shortAvgPx > 0n) {
+        const px1e6 = price / 100n;
+        const diff = px1e6 - c.shortAvgPx;
+        short = (c.shortSizes * diff) / c.shortAvgPx;
+    }
+    const total = spot + c.guaranteedUsd + short;
+    return total > 0n ? total : 0n;
+}
+// ============================================================================
+// computeLiveJlpPriceUsd — the full per-custody fold
+// ============================================================================
+/**
+ * Live JLP price (8-dec) = Σ per-custody USD × 1e8 / jlp_supply.
+ *
+ * Mirrors `compute_live_jlp_price` exactly: reads the pool's custody Vec (order + count from
+ * the pool itself, nothing hardcoded), decodes + guards each custody, prices volatiles off
+ * Doves ([SOL, ETH, BTC]), values stables at $1, sums, requires
+ * Σtarget_ratio_bps == 10000 (layout tripwire), divides by live JLP mint supply, and clamps to
+ * [$0.50, $50].
+ */
+async function computeLiveJlpPriceUsd(connection) {
+    const custodyPks = await getPoolCustodyPubkeys(connection);
+    const keys = [...custodyPks, constants_1.DOVES_SOL_USD, constants_1.DOVES_ETH_USD, constants_1.DOVES_BTC_USD, constants_1.JLP_MINT];
+    const infos = await connection.getMultipleAccountsInfo(keys);
+    const n = custodyPks.length;
+    const dovesSolInfo = infos[n];
+    const dovesEthInfo = infos[n + 1];
+    const dovesBtcInfo = infos[n + 2];
+    const mintInfo = infos[n + 3];
+    if (!dovesSolInfo)
+        throw new Error("live-jlp-price: Doves SOL/USD account not found");
+    if (!dovesEthInfo)
+        throw new Error("live-jlp-price: Doves ETH/USD account not found");
+    if (!dovesBtcInfo)
+        throw new Error("live-jlp-price: Doves BTC/USD account not found");
+    if (!mintInfo)
+        throw new Error("live-jlp-price: JLP mint account not found");
+    const solPrice = parseDovesPrice(dovesSolInfo.data);
+    const ethPrice = parseDovesPrice(dovesEthInfo.data);
+    const btcPrice = parseDovesPrice(dovesBtcInfo.data);
+    if (solPrice <= 0n)
+        throw new Error("live-jlp-price: Doves SOL/USD price non-positive");
+    if (ethPrice <= 0n)
+        throw new Error("live-jlp-price: Doves ETH/USD price non-positive");
+    if (btcPrice <= 0n)
+        throw new Error("live-jlp-price: Doves BTC/USD price non-positive");
+    const volPrices = [solPrice, ethPrice, btcPrice];
+    let aum = 0n;
+    let targetSum = 0n;
+    for (let i = 0; i < n; i++) {
+        const info = infos[i];
+        if (!info)
+            throw new Error(`live-jlp-price: custody account ${custodyPks[i].toBase58()} not found`);
+        const vals = decodeCustodyBytes(info.data, info.owner);
+        targetSum += vals.targetRatioBps;
+        const price = vals.isStable ? 0n : volPrices[volatileDovesIndex(vals.mint)];
+        aum += custodyUsd(vals, price);
+    }
+    if (targetSum !== TARGET_RATIO_BPS_SUM) {
+        throw new Error(`live-jlp-price: Σtarget_ratio_bps == ${targetSum}, expected 10000 (layout tripwire)`);
+    }
+    const mintData = mintInfo.data;
+    if (mintData.length < 44)
+        throw new Error("live-jlp-price: JLP mint account too short");
+    const supply = mintData.readBigUInt64LE(36);
+    if (supply <= 0n)
+        throw new Error("live-jlp-price: JLP mint supply is zero");
+    const price = (aum * 100000000n) / supply;
+    if (price < MIN_JLP_PRICE || price > MAX_JLP_PRICE) {
+        throw new Error(`live-jlp-price: computed price ${price} outside [$0.50, $50] clamp`);
+    }
+    return price;
+}

package/dist/jlpd-strategy/pda.d.ts

@@ -0,0 +1,13 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function findJlpdConfigPda(programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive the per-JlpdConfig `ManagerRole` PDA for JLPD Strategy.
+ * Seeds: `["manager", config, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account (`p-stv-core`
+ * → STV, `elemental-lend` → strategy_state).
+ */
+export declare function findJlpdManagerRolePda(config: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function findStrategyStatePda(baseMint: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function findStvPositionPda(stv: PublicKey, programId?: PublicKey): [PublicKey, number];

package/dist/jlpd-strategy/pda.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findJlpdConfigPda = findJlpdConfigPda;
+exports.findJlpdManagerRolePda = findJlpdManagerRolePda;
+exports.findStrategyStatePda = findStrategyStatePda;
+exports.findStvPositionPda = findStvPositionPda;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+function findJlpdConfigPda(programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.CONFIG_SEED], programId);
+}
+/**
+ * Derive the per-JlpdConfig `ManagerRole` PDA for JLPD Strategy.
+ * Seeds: `["manager", config, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account (`p-stv-core`
+ * → STV, `elemental-lend` → strategy_state).
+ */
+function findJlpdManagerRolePda(config, manager, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MANAGER_SEED, config.toBuffer(), manager.toBuffer()], programId);
+}
+function findStrategyStatePda(baseMint, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STRATEGY_STATE_SEED, baseMint.toBuffer()], programId);
+}
+function findStvPositionPda(stv, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, stv.toBuffer()], programId);
+}

package/dist/jlpd-strategy/settle-yield.d.ts

@@ -0,0 +1,45 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+/** Arguments accepted by `createSettleYieldIx`. */
+export interface CreateSettleYieldIxArgs {
+    manager: PublicKey;
+    /** 5 base asset mints in order: [BTC, ETH, SOL, USDC, JupUSD]. */
+    baseAssetMints: [PublicKey, PublicKey, PublicKey, PublicKey, PublicKey];
+    jlpMint?: PublicKey;
+    tokenProgram?: PublicKey;
+    programId?: PublicKey;
+    /**
+     * Hedge block accounts (position/vault_state pairs per enabled hedge slot,
+     * plus the manifest + earn block), appended after the 15 fixed accounts and
+     * BEFORE `custodyAccounts`. Defaults to `[]` -- for now callers pass nothing
+     * while the hedge is disabled.
+     */
+    hedgeAccounts?: AccountMeta[];
+    /**
+     * JLP pool custody accounts, in the pool `custodies` Vec order (6 today).
+     * REQUIRED on mainnet even when the hedge is off -- consumed by
+     * `compute_live_jlp_price`. Appended last, after `hedgeAccounts`.
+     */
+    custodyAccounts: PublicKey[];
+    /**
+     * Doves price-feed accounts for BTC/ETH/SOL. These MUST equal the on-chain
+     * `strategy_state.price_oracle` of each respective strategy (the program now
+     * validates the passed oracle against the stored feed). To stay rotation-proof,
+     * read each strategy's `priceOracle` from chain and pass it here. If omitted,
+     * falls back to the `DOVES_*_USD` reference constants (correct only while they
+     * match the backfilled on-chain value).
+     */
+    priceOracleBtc?: PublicKey;
+    priceOracleEth?: PublicKey;
+    priceOracleSol?: PublicKey;
+}
+/**
+ * Build a `settle_yield` instruction with automatic PDA derivation.
+ *
+ * Requires the 5 base asset mints in order: [BTC, ETH, SOL, USDC, JupUSD].
+ * These must match the `base_asset_mints` array on the JlpdConfig account.
+ *
+ * Naming follows the SDK convention: low-level instruction builders are named
+ * `create*Ix` (this is the canonical name); high-level transaction wrappers
+ * (if any) are named `build*Transaction`.
+ */
+export declare function createSettleYieldIx(args: CreateSettleYieldIxArgs): TransactionInstruction;