@elmntl/jlpd-sdk 0.13.6 → 0.13.7

package/dist/jlpd-strategy/fluid-view.d.ts

@@ -60,6 +60,14 @@ export interface FluidTick {
  * program — byte-identical to the on-chain `derive_fluid_tick_pda` (golden-vector tested).
  */
 export declare function deriveFluidTickPda(vaultId: number, tick: number): PublicKey;
+/**
+ * Net RAW debt of a decoded position: tick-implied minus dust — the `net_debt_raw` the deployed
+ * partial-repay acceptance predicate is evaluated against (hedge_repay.rs). Supply-only positions
+ * read at the COLD tick and therefore return 0. Dust exceeding the tick-implied debt means the
+ * decoded (tick, collateral, dust) triple is inconsistent — a STRUCTURAL error the caller must
+ * treat as terminal, never as "no debt".
+ */
+export declare function fluidNetDebtRaw(position: FluidPosition): bigint;
 /**
  * The Tick account settle_yield's per-slot triple must carry for `position`: the canonical
  * `Tick(vaultId, position.tick)` for an ACTIVE debt position, or the `Tick(vaultId, MIN_TICK)`

package/dist/jlpd-strategy/fluid-view.js

@@ -20,6 +20,7 @@ exports.FLUID_ZERO_TICK_SCALED_RATIO = exports.JUP_LEND_EARN_MAX_SANE_RATE = exp
 exports.getRatioAtTick = getRatioAtTick;
 exports.decodeFluidPosition = decodeFluidPosition;
 exports.deriveFluidTickPda = deriveFluidTickPda;
+exports.fluidNetDebtRaw = fluidNetDebtRaw;
 exports.settleTickPdaForPosition = settleTickPdaForPosition;
 exports.decodeFluidTick = decodeFluidTick;
 exports.requireFluidPositionLiquidationCurrent = requireFluidPositionLiquidationCurrent;
@@ -296,6 +297,21 @@ function deriveFluidTickPda(vaultId, tick) {
     normalizedLe.writeInt32LE(tick - FLUID_MIN_TICK);
     return web3_js_1.PublicKey.findProgramAddressSync([TICK_SEED, vaultIdLe, normalizedLe], constants_1.JUP_LEND_BORROW_PROGRAM_ID)[0];
 }
+/**
+ * Net RAW debt of a decoded position: tick-implied minus dust — the `net_debt_raw` the deployed
+ * partial-repay acceptance predicate is evaluated against (hedge_repay.rs). Supply-only positions
+ * read at the COLD tick and therefore return 0. Dust exceeding the tick-implied debt means the
+ * decoded (tick, collateral, dust) triple is inconsistent — a STRUCTURAL error the caller must
+ * treat as terminal, never as "no debt".
+ */
+function fluidNetDebtRaw(position) {
+    const tick = position.isSupplyOnly ? FLUID_COLD_TICK : position.tick;
+    const tickDebt = tickImpliedDebtRaw(tick, position.collateralRaw);
+    if (position.dustDebtRaw > tickDebt) {
+        throw new Error(`fluidNetDebtRaw: dust ${position.dustDebtRaw} exceeds tick-implied debt ${tickDebt} — inconsistent position`);
+    }
+    return tickDebt - position.dustDebtRaw;
+}
 /**
  * The Tick account settle_yield's per-slot triple must carry for `position`: the canonical
  * `Tick(vaultId, position.tick)` for an ACTIVE debt position, or the `Tick(vaultId, MIN_TICK)`

package/dist/jlpd-strategy/hedge-derived.d.ts

@@ -10,6 +10,7 @@
 import { PublicKey } from "@solana/web3.js";
 import type { SolanaConnection } from "../common/connection";
 import { type HedgeState, type HedgePositionSlot } from "./hedge-state";
+import { type FluidPosition } from "./fluid-view";
 /**
  * Native decimals for each known hedge debt mint — mirrors `utils/oracle.rs`'s
  * `TOKEN_DECIMALS_{BTC,ETH,SOL,JUPUSD}` constants (the four mints
@@ -62,6 +63,43 @@ export declare function fluidPartialRepayCreditRaw(xNative: bigint, debtDecimals
  * minimum position debt). `netRawDebt` = tick-implied − dust (fluid-view's `netDebtRaw` basis).
  */
 export declare function isPartialRepayAcceptable(xNative: bigint, netRawDebt: bigint, debtDecimals: number, borrowExPrice: bigint): boolean;
+export interface FluidPartialRepayVerdict {
+    accepted: boolean;
+    /** Human reason when refused; null when accepted. */
+    reason: string | null;
+    creditRaw: bigint | null;
+    netRaw: bigint;
+    minDebtRaw: bigint;
+}
+/**
+ * The DEPLOYED acceptance predicate for a partial repay of `x`, evaluated from a decoded
+ * position, extended with the driver's balance precondition (Fluid pulls `x + 1` on payback):
+ *
+ *   x ≥ MIN_OPERATE  ∧  C(x) ≥ 1  ∧  netRaw ≥ C(x) + minDebtRaw  ∧  debtAtaBalance ≥ x + 1
+ *
+ * An EXACT payoff must use the repay-all sentinel — the residual bound enforces that. Throws only
+ * on an INCONSISTENT position (dust > tick-implied), which is structural and terminal.
+ */
+export declare function evaluateFluidPartialRepay(args: {
+    xNative: bigint;
+    position: FluidPosition;
+    borrowExPrice: bigint;
+    debtDecimals: number;
+    debtAtaBalance: bigint;
+}): FluidPartialRepayVerdict;
+/**
+ * Largest acceptable partial repay ≤ `desiredNative` given the position AND the debt-ATA balance
+ * (Fluid's `x + 1` over-pull). Built on `maxPartialRepayNative`'s invert-and-verify, then
+ * re-verified through the full predicate so the ATA bound participates. Null = no acceptable
+ * partial exists — the caller escalates to repay-all (if fundable) or reports top-up-required.
+ */
+export declare function maxAcceptedFluidPartialRepay(args: {
+    desiredNative: bigint;
+    position: FluidPosition;
+    borrowExPrice: bigint;
+    debtDecimals: number;
+    debtAtaBalance: bigint;
+}): bigint | null;
 /**
  * Largest partial repay (native) the on-chain acceptance admits for `netRawDebt` at the given
  * stored price — the driver's sizing cap (anything larger reverts; anything at/below is safe at

package/dist/jlpd-strategy/hedge-derived.js

@@ -18,6 +18,8 @@ exports.clampRepayAmount = clampRepayAmount;
 exports.fluidMinDebtRaw = fluidMinDebtRaw;
 exports.fluidPartialRepayCreditRaw = fluidPartialRepayCreditRaw;
 exports.isPartialRepayAcceptable = isPartialRepayAcceptable;
+exports.evaluateFluidPartialRepay = evaluateFluidPartialRepay;
+exports.maxAcceptedFluidPartialRepay = maxAcceptedFluidPartialRepay;
 exports.maxPartialRepayNative = maxPartialRepayNative;
 exports.fetchHedgeSlotDerived = fetchHedgeSlotDerived;
 exports.fetchAllHedgeSlotsDerived = fetchAllHedgeSlotsDerived;
@@ -157,6 +159,70 @@ function isPartialRepayAcceptable(xNative, netRawDebt, debtDecimals, borrowExPri
     }
     return credit >= 1n && credit + fluidMinDebtRaw(debtDecimals) <= netRawDebt;
 }
+/**
+ * The DEPLOYED acceptance predicate for a partial repay of `x`, evaluated from a decoded
+ * position, extended with the driver's balance precondition (Fluid pulls `x + 1` on payback):
+ *
+ *   x ≥ MIN_OPERATE  ∧  C(x) ≥ 1  ∧  netRaw ≥ C(x) + minDebtRaw  ∧  debtAtaBalance ≥ x + 1
+ *
+ * An EXACT payoff must use the repay-all sentinel — the residual bound enforces that. Throws only
+ * on an INCONSISTENT position (dust > tick-implied), which is structural and terminal.
+ */
+function evaluateFluidPartialRepay(args) {
+    const netRaw = (0, fluid_view_1.fluidNetDebtRaw)(args.position);
+    const minDebtRaw = fluidMinDebtRaw(args.debtDecimals);
+    const base = { netRaw, minDebtRaw };
+    if (args.xNative < exports.FLUID_MIN_OPERATE_NATIVE) {
+        return { accepted: false, reason: `x ${args.xNative} < Fluid minimum ${exports.FLUID_MIN_OPERATE_NATIVE}`, creditRaw: null, ...base };
+    }
+    if (args.debtAtaBalance < args.xNative + 1n) {
+        return {
+            accepted: false,
+            reason: `debt ATA ${args.debtAtaBalance} < x+1 (${args.xNative + 1n}) — Fluid over-pulls one native unit`,
+            creditRaw: null,
+            ...base,
+        };
+    }
+    let creditRaw;
+    try {
+        creditRaw = fluidPartialRepayCreditRaw(args.xNative, args.debtDecimals, args.borrowExPrice);
+    }
+    catch (e) {
+        return { accepted: false, reason: e instanceof Error ? e.message : String(e), creditRaw: null, ...base };
+    }
+    if (creditRaw < 1n || netRaw < creditRaw + minDebtRaw) {
+        return {
+            accepted: false,
+            reason: `residual bound: net ${netRaw} < credit ${creditRaw} + min ${minDebtRaw}`,
+            creditRaw,
+            ...base,
+        };
+    }
+    return { accepted: true, reason: null, creditRaw, ...base };
+}
+/**
+ * Largest acceptable partial repay ≤ `desiredNative` given the position AND the debt-ATA balance
+ * (Fluid's `x + 1` over-pull). Built on `maxPartialRepayNative`'s invert-and-verify, then
+ * re-verified through the full predicate so the ATA bound participates. Null = no acceptable
+ * partial exists — the caller escalates to repay-all (if fundable) or reports top-up-required.
+ */
+function maxAcceptedFluidPartialRepay(args) {
+    const netRaw = (0, fluid_view_1.fluidNetDebtRaw)(args.position);
+    let x = maxPartialRepayNative(netRaw, args.debtDecimals, args.borrowExPrice);
+    if (x <= 0n)
+        return null;
+    if (x > args.desiredNative)
+        x = args.desiredNative;
+    if (args.debtAtaBalance < 2n)
+        return null;
+    if (x > args.debtAtaBalance - 1n)
+        x = args.debtAtaBalance - 1n;
+    for (let i = 0; i < 4 && x >= exports.FLUID_MIN_OPERATE_NATIVE; i++, x -= 1n) {
+        if (evaluateFluidPartialRepay({ ...args, xNative: x }).accepted)
+            return x;
+    }
+    return null;
+}
 /**
  * Largest partial repay (native) the on-chain acceptance admits for `netRawDebt` at the given
  * stored price — the driver's sizing cap (anything larger reverts; anything at/below is safe at

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elmntl/jlpd-sdk",
-  "version": "0.13.6",
-  "description": "SDK for JLP.D (JLP Deconstructed) by Elemental \u2014 p-stv-core, jlpd-strategy, and elemental-lend clients",
+  "version": "0.13.7",
+  "description": "SDK for JLP.D (JLP Deconstructed) by Elemental — p-stv-core, jlpd-strategy, and elemental-lend clients",
   "license": "Apache-2.0",
   "keywords": [
     "solana",
@@ -70,4 +70,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}