@elmntl/jlpd-sdk 0.1.11 → 0.13.4

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

@@ -0,0 +1,135 @@
+/**
+ * Derived-data helpers for the native Jup-Lend hedge — frontend dashboards + driver sizing.
+ * Everything here is either a pure function mirroring an on-chain pure helper
+ * (`state/hedge_state.rs`) exactly, or a thin async composition over `fluid-view.ts` +
+ * `hedge-state.ts` that answers the same questions the on-chain guards answer:
+ *   - per-slot LTV, valued on that slot's OWN pinned Fluid oracle (matches `hedge_borrow`'s /
+ *     `hedge_withdraw_collateral`'s post-op guard basis exactly — see `fluid-view.ts`)
+ *   - pledged collateral summed across every ENABLED slot vs `HedgeState.maxPledgedCollateralJlp`
+ *   - swap-churn budget remaining (`maxSwapNotionalPerSettle - swapNotionalSinceSettle`)
+ */
+import { PublicKey } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+import { type HedgeState, type HedgePositionSlot } from "./hedge-state";
+/**
+ * Native decimals for each known hedge debt mint — mirrors `utils/oracle.rs`'s
+ * `TOKEN_DECIMALS_{BTC,ETH,SOL,JUPUSD}` constants (the four mints
+ * `is_known_hedge_debt_mint` accepts). Throws on an unrecognized mint.
+ */
+export declare function debtMintDecimals(mint: PublicKey): number;
+/**
+ * Map a `HedgePositionSlot.debtMint` to the config-owned manifest ATA its borrow/repay routes
+ * through — mirrors `resolve_debt_manifest_ata` exactly. Returns `PublicKey.default()` (never
+ * throws) for a KNOWN mint whose manifest ATA slot was never backfilled — callers must reject
+ * that themselves; only a genuinely UNKNOWN debt mint throws here.
+ */
+export declare function resolveDebtManifestAta(state: HedgeState, debtMint: PublicKey): PublicKey;
+/** Sum already-decoded per-slot collateral (pure, never throws — for read-only dashboards). */
+export declare function sumPledgedCollateral(perSlotCollateralJlp: bigint[]): bigint;
+/**
+ * Sum already-decoded per-slot collateral and enforce the total against
+ * `HedgeState.maxPledgedCollateralJlp` — mirrors `sum_and_check_pledged_collateral` exactly
+ * (checked addition; throws rather than wrapping past the cap). For DRIVER preflight (reject
+ * before submitting a tx that would revert on-chain); dashboards should use
+ * `sumPledgedCollateral` instead so an (unexpected) over-cap reading still renders.
+ */
+export declare function sumAndCheckPledgedCollateral(perSlotCollateralJlp: bigint[], maxPledgedCollateralJlp: bigint): bigint;
+/**
+ * `hedge_repay` repay-all sentinel (u64::MAX) — the only mode that guarantees `debt == 0`.
+ * Fund the debt ATA to the on-chain budget (ceiled reading + 0.1% + 2 units) and crank the
+ * permissionless `update_exchange_prices` first.
+ */
+export declare const REPAY_ALL_SENTINEL = 18446744073709551615n;
+/**
+ * @deprecated The on-chain clamp is GONE: `hedge_repay` now REJECTS a partial amount that fails
+ * its acceptance predicate instead of clamping it. Size with `maxPartialRepayNative` /
+ * `isPartialRepayAcceptable` below; this function survives only so old scripts still compile,
+ * and its output is no longer guaranteed acceptable on-chain.
+ */
+export declare function clampRepayAmount(requested: bigint, debtBefore: bigint): bigint;
+/** Fluid's minimum native amount per operate leg (`MIN_OPERATE`, pre-scale; all hedge debt mints
+ *  are 6/8/9 decimals). Mirrors the program's `FLUID_MIN_OPERATE_NATIVE`. */
+export declare const FLUID_MIN_OPERATE_NATIVE = 1000n;
+/** Fluid's minimum POSITION debt in raw units (`MIN_DEBT = 1000` scaled by `10^(9−decimals)`) —
+ *  mirrors the program's `fluid_min_debt_raw`. */
+export declare function fluidMinDebtRaw(debtDecimals: number): bigint;
+/** RAW debt Fluid credits for a partial payback of `x` native — mirrors the program's
+ *  `fluid_partial_repay_credit_raw`: `floor(x·10^(9−d)·1e12 / E) − 1`. Throws when the floor term
+ *  is 0 (an `x` too small to credit anything). */
+export declare function fluidPartialRepayCreditRaw(xNative: bigint, debtDecimals: number, borrowExPrice: bigint): bigint;
+/**
+ * Mirror of `hedge_repay`'s on-chain partial acceptance: `x ≥ MIN_OPERATE`, `C(x) ≥ 1`, and
+ * `C(x) + minDebtRaw ≤ netRawDebt` (no excess payback AND the residual stays at/above Fluid's
+ * 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;
+/**
+ * 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
+ * every live price ≥ the stored one). Returns 0n when no partial is acceptable (debt too small —
+ * use the repay-all sentinel instead).
+ */
+export declare function maxPartialRepayNative(netRawDebt: bigint, debtDecimals: number, borrowExPrice: bigint): bigint;
+/**
+ * Swap-churn budget remaining before the next `settle_yield` resets the accumulator — mirrors
+ * `HedgeState.maxSwapNotionalPerSettle - HedgeState.swapNotionalSinceSettle` (USD, 6-dec),
+ * floored at 0 (the accumulator should never on-chain exceed the cap, but this stays
+ * fail-safe against a stale/racing read).
+ */
+export declare function churnBudgetRemainingUsd(state: Pick<HedgeState, "maxSwapNotionalPerSettle" | "swapNotionalSinceSettle">): bigint;
+/**
+ * `HedgeState.maxPledgedCollateralJlp` as a bigint — headroom convenience: pass the result of
+ * `sumAndCheckPledgedCollateral`'s successful total (or a raw sum) to get remaining pledge room.
+ */
+export declare function pledgeHeadroomJlp(state: Pick<HedgeState, "maxPledgedCollateralJlp">, totalPledgedJlp: bigint): bigint;
+/** One enabled `HedgeState.positions` slot's derived valuation. */
+export interface HedgeSlotDerived {
+    slotIndex: number;
+    slot: HedgePositionSlot;
+    /** JLP (6-dec) pledged as collateral in this slot, interest-adjusted. */
+    collateralJlpNative: bigint;
+    /** Outstanding debt, in the debt mint's own native decimals. */
+    debtNative: bigint;
+    debtDecimals: number;
+    /** Liquidation-probability reading in basis points, valued on this slot's OWN Fluid oracle. */
+    ltvBps: number;
+    /** The pair-native oracle price (1e15 precision) this LTV was valued at. */
+    price1e15: bigint;
+}
+/**
+ * Fetch + value ONE `HedgeState.positions[slotIndex]` slot — the async convenience wrapper
+ * matching `hedge_borrow`'s / `hedge_withdraw_collateral`'s post-op LTV guard basis exactly
+ * (see `fluid-view.ts::fetchFluidSlotLtv`). Returns `null` for a disabled slot.
+ */
+export declare function fetchHedgeSlotDerived(connection: SolanaConnection, state: HedgeState, slotIndex: number): Promise<HedgeSlotDerived | null>;
+/**
+ * Fetch + value every ENABLED slot in `HedgeState.positions` (sequentially skips disabled
+ * slots; each enabled slot's fetch runs independently so one slot's RPC error does not hide the
+ * others — callers that want all-or-nothing should wrap in their own try/catch).
+ */
+export declare function fetchAllHedgeSlotsDerived(connection: SolanaConnection, state: HedgeState): Promise<HedgeSlotDerived[]>;
+/**
+ * Portfolio-level hedge exposure: total pledged JLP collateral across every enabled slot (vs
+ * `HedgeState.maxPledgedCollateralJlp`), and per-debt-mint net debt exposure (native units,
+ * keyed by the debt mint's base58 — different debt mints are never summed together, since
+ * they are different tokens).
+ */
+export interface HedgeExposure {
+    /** Σ `collateralJlpNative` across every enabled slot. */
+    totalPledgedCollateralJlp: bigint;
+    /** `HedgeState.maxPledgedCollateralJlp - totalPledgedCollateralJlp`, floored at 0. */
+    pledgeHeadroomJlp: bigint;
+    /**
+     * `totalPledgedCollateralJlp > HedgeState.maxPledgedCollateralJlp` — should never be true given
+     * the on-chain guard (`hedge_supply_collateral` re-scans + rejects this every supply), but
+     * surfaced rather than thrown so a stale/racing read still renders on a dashboard.
+     */
+    pledgeCapExceeded: boolean;
+    /** Per-debt-mint (base58) → summed native debt across every slot borrowing that mint. */
+    debtByMint: Record<string, bigint>;
+    /** Swap-churn budget remaining (USD, 6-dec). */
+    churnBudgetRemainingUsd: bigint;
+    slots: HedgeSlotDerived[];
+}
+/** Compute portfolio-level hedge exposure from a fully-fetched `HedgeState`. */
+export declare function fetchHedgeExposure(connection: SolanaConnection, state: HedgeState): Promise<HedgeExposure>;

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

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Derived-data helpers for the native Jup-Lend hedge — frontend dashboards + driver sizing.
+ * Everything here is either a pure function mirroring an on-chain pure helper
+ * (`state/hedge_state.rs`) exactly, or a thin async composition over `fluid-view.ts` +
+ * `hedge-state.ts` that answers the same questions the on-chain guards answer:
+ *   - per-slot LTV, valued on that slot's OWN pinned Fluid oracle (matches `hedge_borrow`'s /
+ *     `hedge_withdraw_collateral`'s post-op guard basis exactly — see `fluid-view.ts`)
+ *   - pledged collateral summed across every ENABLED slot vs `HedgeState.maxPledgedCollateralJlp`
+ *   - swap-churn budget remaining (`maxSwapNotionalPerSettle - swapNotionalSinceSettle`)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLUID_MIN_OPERATE_NATIVE = exports.REPAY_ALL_SENTINEL = void 0;
+exports.debtMintDecimals = debtMintDecimals;
+exports.resolveDebtManifestAta = resolveDebtManifestAta;
+exports.sumPledgedCollateral = sumPledgedCollateral;
+exports.sumAndCheckPledgedCollateral = sumAndCheckPledgedCollateral;
+exports.clampRepayAmount = clampRepayAmount;
+exports.fluidMinDebtRaw = fluidMinDebtRaw;
+exports.fluidPartialRepayCreditRaw = fluidPartialRepayCreditRaw;
+exports.isPartialRepayAcceptable = isPartialRepayAcceptable;
+exports.maxPartialRepayNative = maxPartialRepayNative;
+exports.churnBudgetRemainingUsd = churnBudgetRemainingUsd;
+exports.pledgeHeadroomJlp = pledgeHeadroomJlp;
+exports.fetchHedgeSlotDerived = fetchHedgeSlotDerived;
+exports.fetchAllHedgeSlotsDerived = fetchAllHedgeSlotsDerived;
+exports.fetchHedgeExposure = fetchHedgeExposure;
+const constants_1 = require("./constants");
+const hedge_state_1 = require("./hedge-state");
+const fluid_view_1 = require("./fluid-view");
+// ---------------------------------------------------------------------------
+// Pure helpers — mirror `state/hedge_state.rs`'s free functions exactly.
+// ---------------------------------------------------------------------------
+/**
+ * Native decimals for each known hedge debt mint — mirrors `utils/oracle.rs`'s
+ * `TOKEN_DECIMALS_{BTC,ETH,SOL,JUPUSD}` constants (the four mints
+ * `is_known_hedge_debt_mint` accepts). Throws on an unrecognized mint.
+ */
+function debtMintDecimals(mint) {
+    if (mint.equals(constants_1.MINT_JUPUSD))
+        return 6;
+    if (mint.equals(constants_1.MINT_WSOL))
+        return 9;
+    if (mint.equals(constants_1.MINT_WBTC))
+        return 8;
+    if (mint.equals(constants_1.MINT_WETH))
+        return 8;
+    throw new Error(`debtMintDecimals: unrecognized hedge debt mint ${mint.toBase58()}`);
+}
+/**
+ * Map a `HedgePositionSlot.debtMint` to the config-owned manifest ATA its borrow/repay routes
+ * through — mirrors `resolve_debt_manifest_ata` exactly. Returns `PublicKey.default()` (never
+ * throws) for a KNOWN mint whose manifest ATA slot was never backfilled — callers must reject
+ * that themselves; only a genuinely UNKNOWN debt mint throws here.
+ */
+function resolveDebtManifestAta(state, debtMint) {
+    if (debtMint.equals(constants_1.MINT_JUPUSD))
+        return state.jupusd;
+    if (debtMint.equals(constants_1.MINT_WSOL))
+        return state.wsol;
+    if (debtMint.equals(constants_1.MINT_WBTC))
+        return state.wbtc;
+    if (debtMint.equals(constants_1.MINT_WETH))
+        return state.weth;
+    throw new Error(`resolveDebtManifestAta: unrecognized hedge debt mint ${debtMint.toBase58()}`);
+}
+/** Sum already-decoded per-slot collateral (pure, never throws — for read-only dashboards). */
+function sumPledgedCollateral(perSlotCollateralJlp) {
+    let total = 0n;
+    for (const c of perSlotCollateralJlp) {
+        total += c;
+    }
+    return total;
+}
+/**
+ * Sum already-decoded per-slot collateral and enforce the total against
+ * `HedgeState.maxPledgedCollateralJlp` — mirrors `sum_and_check_pledged_collateral` exactly
+ * (checked addition; throws rather than wrapping past the cap). For DRIVER preflight (reject
+ * before submitting a tx that would revert on-chain); dashboards should use
+ * `sumPledgedCollateral` instead so an (unexpected) over-cap reading still renders.
+ */
+function sumAndCheckPledgedCollateral(perSlotCollateralJlp, maxPledgedCollateralJlp) {
+    const total = sumPledgedCollateral(perSlotCollateralJlp);
+    if (total > maxPledgedCollateralJlp) {
+        throw new Error(`sumAndCheckPledgedCollateral: total pledged ${total} exceeds cap ${maxPledgedCollateralJlp}`);
+    }
+    return total;
+}
+/**
+ * `hedge_repay` repay-all sentinel (u64::MAX) — the only mode that guarantees `debt == 0`.
+ * Fund the debt ATA to the on-chain budget (ceiled reading + 0.1% + 2 units) and crank the
+ * permissionless `update_exchange_prices` first.
+ */
+exports.REPAY_ALL_SENTINEL = 18446744073709551615n; // u64::MAX
+/**
+ * @deprecated The on-chain clamp is GONE: `hedge_repay` now REJECTS a partial amount that fails
+ * its acceptance predicate instead of clamping it. Size with `maxPartialRepayNative` /
+ * `isPartialRepayAcceptable` below; this function survives only so old scripts still compile,
+ * and its output is no longer guaranteed acceptable on-chain.
+ */
+function clampRepayAmount(requested, debtBefore) {
+    if (requested === exports.REPAY_ALL_SENTINEL)
+        return exports.REPAY_ALL_SENTINEL;
+    return requested < debtBefore ? requested : debtBefore;
+}
+/** Fluid's minimum native amount per operate leg (`MIN_OPERATE`, pre-scale; all hedge debt mints
+ *  are 6/8/9 decimals). Mirrors the program's `FLUID_MIN_OPERATE_NATIVE`. */
+exports.FLUID_MIN_OPERATE_NATIVE = 1000n;
+const EX_PRICE_PRECISION = 1000000000000n; // 1e12
+const FLUID_MAX_TOKEN_DECIMALS = 9;
+function fluidScale(debtDecimals) {
+    if (!Number.isInteger(debtDecimals) || debtDecimals < 4 || debtDecimals > FLUID_MAX_TOKEN_DECIMALS) {
+        throw new RangeError(`fluidScale: unsupported debt decimals ${debtDecimals}`);
+    }
+    return 10n ** BigInt(FLUID_MAX_TOKEN_DECIMALS - debtDecimals);
+}
+/** Fluid's minimum POSITION debt in raw units (`MIN_DEBT = 1000` scaled by `10^(9−decimals)`) —
+ *  mirrors the program's `fluid_min_debt_raw`. */
+function fluidMinDebtRaw(debtDecimals) {
+    return 1000n * fluidScale(debtDecimals);
+}
+/** RAW debt Fluid credits for a partial payback of `x` native — mirrors the program's
+ *  `fluid_partial_repay_credit_raw`: `floor(x·10^(9−d)·1e12 / E) − 1`. Throws when the floor term
+ *  is 0 (an `x` too small to credit anything). */
+function fluidPartialRepayCreditRaw(xNative, debtDecimals, borrowExPrice) {
+    const floored = (xNative * fluidScale(debtDecimals) * EX_PRICE_PRECISION) / borrowExPrice;
+    if (floored < 1n)
+        throw new Error("fluidPartialRepayCreditRaw: credit floors to zero");
+    return floored - 1n;
+}
+/**
+ * Mirror of `hedge_repay`'s on-chain partial acceptance: `x ≥ MIN_OPERATE`, `C(x) ≥ 1`, and
+ * `C(x) + minDebtRaw ≤ netRawDebt` (no excess payback AND the residual stays at/above Fluid's
+ * minimum position debt). `netRawDebt` = tick-implied − dust (fluid-view's `netDebtRaw` basis).
+ */
+function isPartialRepayAcceptable(xNative, netRawDebt, debtDecimals, borrowExPrice) {
+    if (xNative < exports.FLUID_MIN_OPERATE_NATIVE)
+        return false;
+    let credit;
+    try {
+        credit = fluidPartialRepayCreditRaw(xNative, debtDecimals, borrowExPrice);
+    }
+    catch {
+        return false;
+    }
+    return credit >= 1n && credit + fluidMinDebtRaw(debtDecimals) <= netRawDebt;
+}
+/**
+ * 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
+ * every live price ≥ the stored one). Returns 0n when no partial is acceptable (debt too small —
+ * use the repay-all sentinel instead).
+ */
+function maxPartialRepayNative(netRawDebt, debtDecimals, borrowExPrice) {
+    const minDebt = fluidMinDebtRaw(debtDecimals);
+    if (netRawDebt <= minDebt)
+        return 0n;
+    const scale = fluidScale(debtDecimals);
+    // Invert C(x) ≤ netRaw − minDebt: x ≤ (netRaw − minDebt + 1)·E / (1e12·scale); verify + step
+    // down for the integer-floor edge.
+    let x = ((netRawDebt - minDebt + 1n) * borrowExPrice) / (EX_PRICE_PRECISION * scale);
+    while (x >= exports.FLUID_MIN_OPERATE_NATIVE && !isPartialRepayAcceptable(x, netRawDebt, debtDecimals, borrowExPrice)) {
+        x -= 1n;
+    }
+    return x >= exports.FLUID_MIN_OPERATE_NATIVE ? x : 0n;
+}
+/**
+ * Swap-churn budget remaining before the next `settle_yield` resets the accumulator — mirrors
+ * `HedgeState.maxSwapNotionalPerSettle - HedgeState.swapNotionalSinceSettle` (USD, 6-dec),
+ * floored at 0 (the accumulator should never on-chain exceed the cap, but this stays
+ * fail-safe against a stale/racing read).
+ */
+function churnBudgetRemainingUsd(state) {
+    const max = BigInt(state.maxSwapNotionalPerSettle.toString());
+    const since = BigInt(state.swapNotionalSinceSettle.toString());
+    const remaining = max - since;
+    return remaining > 0n ? remaining : 0n;
+}
+/**
+ * `HedgeState.maxPledgedCollateralJlp` as a bigint — headroom convenience: pass the result of
+ * `sumAndCheckPledgedCollateral`'s successful total (or a raw sum) to get remaining pledge room.
+ */
+function pledgeHeadroomJlp(state, totalPledgedJlp) {
+    const cap = BigInt(state.maxPledgedCollateralJlp.toString());
+    const headroom = cap - totalPledgedJlp;
+    return headroom > 0n ? headroom : 0n;
+}
+/**
+ * Fetch + value ONE `HedgeState.positions[slotIndex]` slot — the async convenience wrapper
+ * matching `hedge_borrow`'s / `hedge_withdraw_collateral`'s post-op LTV guard basis exactly
+ * (see `fluid-view.ts::fetchFluidSlotLtv`). Returns `null` for a disabled slot.
+ */
+async function fetchHedgeSlotDerived(connection, state, slotIndex) {
+    if (slotIndex < 0 || slotIndex >= constants_1.MAX_HEDGE_POSITIONS) {
+        throw new Error(`fetchHedgeSlotDerived: slotIndex ${slotIndex} out of bounds [0, ${constants_1.MAX_HEDGE_POSITIONS})`);
+    }
+    const slot = state.positions[slotIndex];
+    if ((0, hedge_state_1.isHedgePositionSlotDisabled)(slot))
+        return null;
+    const decimals = debtMintDecimals(slot.debtMint);
+    const { ltvBps, debtNative, collateralJlpNative, price1e15 } = await (0, fluid_view_1.fetchFluidSlotLtv)(connection, slot, decimals);
+    return { slotIndex, slot, collateralJlpNative, debtNative, debtDecimals: decimals, ltvBps, price1e15 };
+}
+/**
+ * Fetch + value every ENABLED slot in `HedgeState.positions` (sequentially skips disabled
+ * slots; each enabled slot's fetch runs independently so one slot's RPC error does not hide the
+ * others — callers that want all-or-nothing should wrap in their own try/catch).
+ */
+async function fetchAllHedgeSlotsDerived(connection, state) {
+    const results = await Promise.all(state.positions.map((slot, slotIndex) => (0, hedge_state_1.isHedgePositionSlotDisabled)(slot) ? Promise.resolve(null) : fetchHedgeSlotDerived(connection, state, slotIndex)));
+    return results.filter((r) => r !== null);
+}
+/** Compute portfolio-level hedge exposure from a fully-fetched `HedgeState`. */
+async function fetchHedgeExposure(connection, state) {
+    const slots = await fetchAllHedgeSlotsDerived(connection, state);
+    const totalPledgedCollateralJlp = sumPledgedCollateral(slots.map((s) => s.collateralJlpNative));
+    const cap = BigInt(state.maxPledgedCollateralJlp.toString());
+    const debtByMint = {};
+    for (const s of slots) {
+        const key = s.slot.debtMint.toBase58();
+        debtByMint[key] = (debtByMint[key] ?? 0n) + s.debtNative;
+    }
+    return {
+        totalPledgedCollateralJlp,
+        pledgeHeadroomJlp: cap - totalPledgedCollateralJlp > 0n ? cap - totalPledgedCollateralJlp : 0n,
+        pledgeCapExceeded: totalPledgedCollateralJlp > cap,
+        debtByMint,
+        churnBudgetRemainingUsd: churnBudgetRemainingUsd(state),
+        slots,
+    };
+}

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

@@ -0,0 +1,210 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+import BN from "bn.js";
+import type { HedgePositionSlot } from "./hedge-state";
+/** Common account inputs shared by every native hedge op. */
+export interface HedgeOpAccounts {
+    manager: PublicKey;
+    config: PublicKey;
+    managerRole: PublicKey;
+    hedgeState: PublicKey;
+    /** JLP source (supply/borrow/repay) or destination (withdraw) ATA — must equal `JlpdConfig.vault_jlp_ata`. */
+    jlpSourceAta: PublicKey;
+    /** This slot's debt-manifest ATA — resolved from `HedgeState` off-chain (`resolveDebtManifestAta` in hedge-derived.ts). */
+    debtAta: PublicKey;
+    jlpMint: PublicKey;
+    /** This slot's `HedgePositionSlot.debtMint`. */
+    debtMint: PublicKey;
+    /** This slot's `HedgePositionSlot.fluidOracle`. */
+    fluidOracle: PublicKey;
+    /** This slot's `HedgePositionSlot.borrowPosition`. */
+    borrowPosition: PublicKey;
+    /** This slot's `HedgePositionSlot.vaultConfig`. */
+    vaultConfig: PublicKey;
+    /** This slot's `HedgePositionSlot.vaultState`. */
+    vaultState: PublicKey;
+    jupLendBorrowProgram?: PublicKey;
+    tokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+    systemProgram?: PublicKey;
+    /**
+     * Fully-ordered remaining accounts for this op (see this module's doc comment for the exact
+     * per-op sub-partition). The caller assembles these (Fluid operate() passthrough + oracle
+     * feed / pledge-scan slices); this builder does not.
+     */
+    remainingAccounts?: AccountMeta[];
+}
+export interface CreateHedgeSupplyCollateralIxArgs extends HedgeOpAccounts {
+    slotIndex: number;
+    /** JLP (base units, 6 decimals) to pledge as collateral. */
+    amount: bigint | BN;
+}
+/** Build the on-chain `hedge_supply_collateral` instruction. */
+export declare function createHedgeSupplyCollateralIx(args: CreateHedgeSupplyCollateralIxArgs, programId?: PublicKey): TransactionInstruction;
+export interface CreateHedgeBorrowIxArgs extends HedgeOpAccounts {
+    slotIndex: number;
+    /** Debt-mint-native amount to borrow. */
+    amount: bigint | BN;
+}
+/** Build the on-chain `hedge_borrow` instruction. */
+export declare function createHedgeBorrowIx(args: CreateHedgeBorrowIxArgs, programId?: PublicKey): TransactionInstruction;
+export interface CreateHedgeRepayIxArgs extends HedgeOpAccounts {
+    slotIndex: number;
+    /** Debt-mint-native amount REQUESTED to repay — must satisfy the on-chain acceptance predicate
+     *  (no clamping), or the repay-all sentinel. */
+    amount: bigint | BN;
+    /** The position's canonical Fluid Tick — `deriveFluidTickPda(vaultId, position.tick)` /
+     *  `settleTickPdaForPosition(position)` from a fresh position read. The program validates it
+     *  and rejects a liquidation-stale position outright. */
+    fluidTick: PublicKey;
+}
+/** Build the on-chain `hedge_repay` instruction. */
+export declare function createHedgeRepayIx(args: CreateHedgeRepayIxArgs, programId?: PublicKey): TransactionInstruction;
+export interface CreateHedgeWithdrawCollateralIxArgs extends HedgeOpAccounts {
+    slotIndex: number;
+    /** JLP (base units, 6 decimals) to withdraw from the position's collateral. */
+    amount: bigint | BN;
+}
+/** Build the on-chain `hedge_withdraw_collateral` instruction. */
+export declare function createHedgeWithdrawCollateralIx(args: CreateHedgeWithdrawCollateralIxArgs, programId?: PublicKey): TransactionInstruction;
+/**
+ * Mirrors the on-chain `HedgeManifestRole` enum exactly (`instructions/hedge/hedge_swap.rs`) —
+ * Borsh-serializes as a single `u8` by declaration order, which coincides with each variant's
+ * explicit `= N` discriminant (verified by the Rust module's own
+ * `test_borsh_round_trip_matches_declared_discriminants`).
+ */
+export declare enum HedgeManifestRole {
+    JupUsd = 0,
+    JupSol = 1,
+    Wbtc = 2,
+    Weth = 3,
+    Wsol = 4,
+    JlJupUsd = 5,
+    JlWbtc = 6,
+    JlWeth = 7
+}
+/** Account inputs for `createHedgeSwapIx`. */
+export interface CreateHedgeSwapIxArgs {
+    manager: PublicKey;
+    config: PublicKey;
+    managerRole: PublicKey;
+    hedgeState: PublicKey;
+    /** Must equal `manifest_role_ata(hedge_state, params.srcRole)`. */
+    srcAta: PublicKey;
+    /** Must equal `manifest_role_ata(hedge_state, params.dstRole)`. */
+    dstAta: PublicKey;
+    /** Doves oracle for `srcRole` — any account if `srcRole` isn't Doves-priced (Wbtc/Weth/Wsol/JupSol). */
+    priceOracleSrc: PublicKey;
+    /** Doves oracle for `dstRole` — same rules as `priceOracleSrc`. */
+    priceOracleDst: PublicKey;
+    /** StrategyState PDA for `srcRole`'s base asset — any account if unused. */
+    strategyStateSrc: PublicKey;
+    /** StrategyState PDA for `dstRole`'s base asset — any account if unused. */
+    strategyStateDst: PublicKey;
+    /** Jup-Lend Earn `lending` account for `srcRole` if it's an fToken role — any account otherwise. */
+    lendingSrc: PublicKey;
+    /** Jup-Lend Earn `lending` account for `dstRole` — same rules as `lendingSrc`. */
+    lendingDst: PublicKey;
+    /**
+     * JupSOL Sanctum stake-pool account — only actually validated on-chain when `srcRole` or
+     * `dstRole` is `HedgeManifestRole.JupSol`. Defaults to the pinned `JUPSOL_STAKE_POOL_ACCOUNT` so
+     * callers whose swap never touches JupSol don't need to think about it.
+     */
+    jupsolRate?: PublicKey;
+    jupiterProgram?: PublicKey;
+    srcRole: HedgeManifestRole;
+    dstRole: HedgeManifestRole;
+    /** Amount of `srcRole` to spend (native units). */
+    amountIn: bigint | BN;
+    /** Caller-supplied minimum acceptable output — the on-chain floor is `max(minOut, oracle_floor)`. */
+    minOut: bigint | BN;
+    /** Jupiter swap instruction data (discriminator + route). Can be empty on devnet/localnet. */
+    jupiterData: Buffer | Uint8Array;
+    /**
+     * Fully-ordered Jupiter route accounts (source must be `srcAta`, destination must be `dstAta`) —
+     * unchanged passthrough, exactly like `createBaseToBaseSwapIx`'s `remainingAccounts`.
+     */
+    remainingAccounts?: AccountMeta[];
+}
+/**
+ * Build the on-chain `hedge_swap` instruction — see this module's `hedge_swap` section doc
+ * comment above for the full account-order rationale and the JupSOL stake-pool default.
+ *
+ * Instruction data layout (Anchor Borsh, `HedgeSwapParams`):
+ *   [8-byte disc, 1-byte src_role, 1-byte dst_role, 8-byte amount_in (LE), 8-byte min_out (LE),
+ *    4-byte jupiter_data_len (LE), ...jupiter_data_bytes]
+ *
+ * A JupSol leg requires a FRESH (epoch-current) `jupsolRate` stake-pool account — a stale pool
+ * reverts `StaleJupSolStakePool` on-chain.
+ */
+export declare function createHedgeSwapIx(args: CreateHedgeSwapIxArgs, programId?: PublicKey): TransactionInstruction;
+/**
+ * One `HedgePositionSlot` update param — mirrors the on-chain `HedgePositionSlotParams`
+ * (init_or_update_hedge_state.rs). Structurally identical to the decode-side `HedgePositionSlot`
+ * (hedge-state.ts): re-exported under the Rust param-struct name for call-site clarity.
+ */
+export type HedgePositionSlotParams = HedgePositionSlot;
+/** Account inputs + Borsh params for `createInitOrUpdateHedgeStateIx`. */
+export interface InitOrUpdateHedgeStateArgs {
+    /** Rent payer; must equal `JlpdConfig.admin` on both init and update. Signer + writable. */
+    payer: PublicKey;
+    /** The JLPD Config PDA (already initialized). */
+    config: PublicKey;
+    /** The HedgeState PDA — seeds `["hedge", config]` (`findHedgeStatePda` in hedge-state.ts). */
+    hedgeState: PublicKey;
+    tokenProgram?: PublicKey;
+    systemProgram?: PublicKey;
+    /**
+     * Exactly `MAX_HEDGE_POSITIONS` (4) entries, slot-index order, or omitted/empty to leave every
+     * slot untouched. `null` at index `i` leaves `HedgeState.positions[i]` as-is (Borsh `None`); a
+     * `HedgePositionSlotParams` value fully replaces that slot (Borsh `Some`) — there is no partial
+     * per-field slot update on-chain.
+     */
+    positions?: (HedgePositionSlotParams | null)[];
+    /** Config-owned JupUSD ATA (compile-time mint `MINT_JUPUSD`). `null`/omitted = unchanged. */
+    jupusd?: PublicKey | null;
+    /** Config-owned JupSOL ATA (compile-time mint `MINT_JUPSOL`). `null`/omitted = unchanged. */
+    jupsol?: PublicKey | null;
+    /** Config-owned wBTC ATA (compile-time mint `MINT_WBTC`). `null`/omitted = unchanged. */
+    wbtc?: PublicKey | null;
+    /** Config-owned wETH ATA (compile-time mint `MINT_WETH`). `null`/omitted = unchanged. */
+    weth?: PublicKey | null;
+    /** Config-owned wSOL ATA (compile-time mint `MINT_WSOL`). `null`/omitted = unchanged. */
+    wsol?: PublicKey | null;
+    /** Config-owned JupUSD Earn fToken ATA. `null`/omitted = unchanged. */
+    jlJupusd?: PublicKey | null;
+    /** Config-owned wBTC Earn fToken ATA (disabled until wired). `null`/omitted = unchanged. */
+    jlWbtc?: PublicKey | null;
+    /** Config-owned wETH Earn fToken ATA (disabled until wired). `null`/omitted = unchanged. */
+    jlWeth?: PublicKey | null;
+    /** Admin-set JupUSD Earn fToken mint (`Pubkey.default()` = unset). `null`/omitted = unchanged. */
+    jlJupusdMint?: PublicKey | null;
+    /** Admin-set wBTC Earn fToken mint. `null`/omitted = unchanged. */
+    jlWbtcMint?: PublicKey | null;
+    /** Admin-set wETH Earn fToken mint. `null`/omitted = unchanged. */
+    jlWethMint?: PublicKey | null;
+    /** JupUSD Earn `lending` rate-source account. `null`/omitted = unchanged. */
+    jlJupusdLending?: PublicKey | null;
+    /** wBTC Earn `lending` rate-source account. `null`/omitted = unchanged. */
+    jlWbtcLending?: PublicKey | null;
+    /** wETH Earn `lending` rate-source account. `null`/omitted = unchanged. */
+    jlWethLending?: PublicKey | null;
+    /** JLP-native pledge cap (base units, 6 decimals). `null`/omitted = unchanged (init: 0). */
+    maxPledgedCollateralJlp?: bigint | BN | null;
+    /** Per-settle swap-churn budget (USD, 6-dec). `null`/omitted = unchanged (init: 0). */
+    maxSwapNotionalPerSettle?: bigint | BN | null;
+    /** Pair-native per-position LTV cap, bps (0..=`MAX_HEDGE_LTV_BPS`). `null`/omitted = unchanged (init: 0). */
+    maxLtvBps?: number | null;
+    /** Hedge master switch. `null`/omitted = unchanged (init: false). */
+    enabled?: boolean | null;
+    /**
+     * Config-owned token accounts backing any manifest ATA slot set to a NEW value this call
+     * (order-independent, matched by pubkey on-chain). An unchanged slot needs none.
+     */
+    remainingAccounts?: AccountMeta[];
+}
+/**
+ * Build the on-chain `init_or_update_hedge_state` instruction (provisions/updates the singleton
+ * `HedgeState` PDA). See this section's module doc comment above for the full account list and
+ * Borsh field order.
+ */
+export declare function createInitOrUpdateHedgeStateIx(args: InitOrUpdateHedgeStateArgs, programId?: PublicKey): TransactionInstruction;