@elmntl/jlpd-sdk 0.2.0 → 0.13.5

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

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HedgeManifestRole = void 0;
+exports.createHedgeSupplyCollateralIx = createHedgeSupplyCollateralIx;
+exports.createHedgeBorrowIx = createHedgeBorrowIx;
+exports.createHedgeRepayIx = createHedgeRepayIx;
+exports.createHedgeWithdrawCollateralIx = createHedgeWithdrawCollateralIx;
+exports.createHedgeSwapIx = createHedgeSwapIx;
+exports.createInitOrUpdateHedgeStateIx = createInitOrUpdateHedgeStateIx;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+const buffer_1 = require("../common/buffer");
+const constants_1 = require("./constants");
+function toBigIntAmount(v) {
+    if (typeof v === "bigint")
+        return v;
+    const asBn = v;
+    return typeof asBn.toBigInt === "function" ? asBn.toBigInt() : BigInt(asBn.toString());
+}
+/** Serialize `{ slot_index: u8, amount: u64 }`, Borsh-identical across all four hedge ops. */
+function serializeSlotIndexAmountParams(disc, slotIndex, amount) {
+    if (!Number.isInteger(slotIndex) || slotIndex < 0 || slotIndex > 255) {
+        throw new RangeError(`slotIndex must be an integer in 0..255, got ${slotIndex}`);
+    }
+    const data = Buffer.alloc(8 + 1 + 8);
+    disc.copy(data, 0);
+    data.writeUInt8(slotIndex, 8);
+    data.writeBigUInt64LE(toBigIntAmount(amount), 9);
+    return data;
+}
+function buildHedgeOpKeys(args) {
+    const { manager, config, managerRole, hedgeState, jlpSourceAta, debtAta, jlpMint, debtMint, fluidOracle, borrowPosition, vaultConfig, vaultState, jupLendBorrowProgram = constants_1.JUP_LEND_BORROW_PROGRAM_ID, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, associatedTokenProgram = spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, systemProgram = web3_js_1.SystemProgram.programId, remainingAccounts = [], } = args;
+    return [
+        { pubkey: manager, isSigner: true, isWritable: false },
+        { pubkey: config, isSigner: false, isWritable: true },
+        { pubkey: managerRole, isSigner: false, isWritable: false },
+        { pubkey: hedgeState, isSigner: false, isWritable: false },
+        { pubkey: jlpSourceAta, isSigner: false, isWritable: true },
+        { pubkey: debtAta, isSigner: false, isWritable: true },
+        { pubkey: jlpMint, isSigner: false, isWritable: false },
+        { pubkey: debtMint, isSigner: false, isWritable: false },
+        { pubkey: fluidOracle, isSigner: false, isWritable: false },
+        { pubkey: borrowPosition, isSigner: false, isWritable: true },
+        { pubkey: vaultConfig, isSigner: false, isWritable: false },
+        { pubkey: vaultState, isSigner: false, isWritable: true },
+        { pubkey: jupLendBorrowProgram, isSigner: false, isWritable: false },
+        { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        { pubkey: associatedTokenProgram, isSigner: false, isWritable: false },
+        { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ...remainingAccounts,
+    ];
+}
+/** Build the on-chain `hedge_supply_collateral` instruction. */
+function createHedgeSupplyCollateralIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = serializeSlotIndexAmountParams(constants_1.IX_HEDGE_SUPPLY_COLLATERAL, args.slotIndex, args.amount);
+    return new web3_js_1.TransactionInstruction({ keys: buildHedgeOpKeys(args), programId, data });
+}
+/** Build the on-chain `hedge_borrow` instruction. */
+function createHedgeBorrowIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = serializeSlotIndexAmountParams(constants_1.IX_HEDGE_BORROW, args.slotIndex, args.amount);
+    return new web3_js_1.TransactionInstruction({ keys: buildHedgeOpKeys(args), programId, data });
+}
+/** Build the on-chain `hedge_repay` instruction. */
+function createHedgeRepayIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = serializeSlotIndexAmountParams(constants_1.IX_HEDGE_REPAY, args.slotIndex, args.amount);
+    return new web3_js_1.TransactionInstruction({ keys: buildHedgeOpKeys(args), programId, data });
+}
+/** Build the on-chain `hedge_withdraw_collateral` instruction. */
+function createHedgeWithdrawCollateralIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = serializeSlotIndexAmountParams(constants_1.IX_HEDGE_WITHDRAW_COLLATERAL, args.slotIndex, args.amount);
+    return new web3_js_1.TransactionInstruction({ keys: buildHedgeOpKeys(args), programId, data });
+}
+// ---------------------------------------------------------------------------
+// hedge_swap — the general, RISK-INCREASING hedge swap between two `HedgeState` manifest ATAs
+// via Jupiter. BLOCKED while the hedge is disabled (unlike the risk-decreasing hedge ops above).
+//
+// Account order verified against `instructions/hedge/hedge_swap.rs`'s `#[derive(Accounts)]
+// HedgeSwap` struct (post-B0): the B0 change inserted a NEW fixed account, `jupsol_rate`, at
+// position 13 (0-indexed 12) between `lending_dst` and `jupiter_program` — `jupiter_program` is
+// therefore now position 14 (0-indexed 13), not 13. NOTE: `target/idl/jlpd_strategy.json` has NOT
+// been regenerated since B0 landed — its `hedge_swap.accounts` list is stale (13 entries, missing
+// `jupsol_rate`); the discriminator and `HedgeSwapParams`/`HedgeManifestRole` type entries in that
+// same IDL DO match the Rust source (params/enum are unaffected by B0 — only the account list
+// changed), so this builder trusts the Rust struct for account order and the IDL for the
+// discriminator + param shape.
+//
+// Fixed accounts (14):
+//   0.  manager             [signer]
+//   1.  config               []          JLPD Config PDA (read-only — this ix never writes it)
+//   2.  manager_role          []          ManagerRole PDA
+//   3.  hedge_state          [writable]  writes swap_notional_since_settle
+//   4.  src_ata              [writable]  == manifest_role_ata(hedge_state, params.src_role)
+//   5.  dst_ata              [writable]  == manifest_role_ata(hedge_state, params.dst_role)
+//   6.  price_oracle_src      []          Doves oracle for src_role, if Doves-priced; else unused
+//   7.  price_oracle_dst      []          Doves oracle for dst_role; same rules
+//   8.  strategy_state_src    []          StrategyState PDA for src_role's base asset; else unused
+//   9.  strategy_state_dst    []          StrategyState PDA for dst_role's base asset; else unused
+//   10. lending_src           []          Jup-Lend Earn `lending` for src_role if an fToken role; else unused
+//   11. lending_dst           []          Jup-Lend Earn `lending` for dst_role; same rules
+//   12. jupsol_rate           []          JupSOL Sanctum stake-pool account — ONE shared account
+//                                          regardless of which leg (or both) is JupSol; unused
+//                                          otherwise. Defaults to `JUPSOL_STAKE_POOL_ACCOUNT`.
+//   13. jupiter_program       []          Jupiter aggregator program
+//
+// remaining_accounts: the caller-supplied Jupiter route accounts (source must be src_ata,
+// destination must be dst_ata) — unchanged passthrough, exactly like base_to_base_swap.
+//
+// A JupSol leg additionally requires the `jupsol_rate` stake-pool account to be EPOCH-FRESH
+// (cranked this epoch) — a stale pool reverts `StaleJupSolStakePool` even though the fixed
+// address/owner/mint pin passes. See `oracle::jupsol_to_sol_native`'s module doc for the
+// chain-verified rate-source spec.
+// ---------------------------------------------------------------------------
+/**
+ * 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`).
+ */
+var HedgeManifestRole;
+(function (HedgeManifestRole) {
+    HedgeManifestRole[HedgeManifestRole["JupUsd"] = 0] = "JupUsd";
+    HedgeManifestRole[HedgeManifestRole["JupSol"] = 1] = "JupSol";
+    HedgeManifestRole[HedgeManifestRole["Wbtc"] = 2] = "Wbtc";
+    HedgeManifestRole[HedgeManifestRole["Weth"] = 3] = "Weth";
+    HedgeManifestRole[HedgeManifestRole["Wsol"] = 4] = "Wsol";
+    HedgeManifestRole[HedgeManifestRole["JlJupUsd"] = 5] = "JlJupUsd";
+    HedgeManifestRole[HedgeManifestRole["JlWbtc"] = 6] = "JlWbtc";
+    HedgeManifestRole[HedgeManifestRole["JlWeth"] = 7] = "JlWeth";
+})(HedgeManifestRole || (exports.HedgeManifestRole = HedgeManifestRole = {}));
+/**
+ * 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.
+ */
+function createHedgeSwapIx(args, programId = constants_1.PROGRAM_ID) {
+    const { manager, config, managerRole, hedgeState, srcAta, dstAta, priceOracleSrc, priceOracleDst, strategyStateSrc, strategyStateDst, lendingSrc, lendingDst, jupsolRate = constants_1.JUPSOL_STAKE_POOL_ACCOUNT, jupiterProgram = constants_1.JUPITER_PROGRAM, srcRole, dstRole, amountIn, minOut, jupiterData, remainingAccounts = [], } = args;
+    const amountInBi = toBigIntAmount(amountIn);
+    const minOutBi = toBigIntAmount(minOut);
+    const jupBytes = Buffer.from(jupiterData);
+    const dataLen = 8 + 1 + 1 + 8 + 8 + 4 + jupBytes.length;
+    const data = Buffer.alloc(dataLen);
+    constants_1.IX_HEDGE_SWAP.copy(data, 0);
+    data.writeUInt8(srcRole, 8);
+    data.writeUInt8(dstRole, 9);
+    data.writeBigUInt64LE(amountInBi, 10);
+    data.writeBigUInt64LE(minOutBi, 18);
+    data.writeUInt32LE(jupBytes.length, 26);
+    jupBytes.copy(data, 30);
+    const keys = [
+        { pubkey: manager, isSigner: true, isWritable: false },
+        { pubkey: config, isSigner: false, isWritable: false },
+        { pubkey: managerRole, isSigner: false, isWritable: false },
+        { pubkey: hedgeState, isSigner: false, isWritable: true },
+        { pubkey: srcAta, isSigner: false, isWritable: true },
+        { pubkey: dstAta, isSigner: false, isWritable: true },
+        { pubkey: priceOracleSrc, isSigner: false, isWritable: false },
+        { pubkey: priceOracleDst, isSigner: false, isWritable: false },
+        { pubkey: strategyStateSrc, isSigner: false, isWritable: false },
+        { pubkey: strategyStateDst, isSigner: false, isWritable: false },
+        { pubkey: lendingSrc, isSigner: false, isWritable: false },
+        { pubkey: lendingDst, isSigner: false, isWritable: false },
+        { pubkey: jupsolRate, isSigner: false, isWritable: false },
+        { pubkey: jupiterProgram, isSigner: false, isWritable: false },
+        ...remainingAccounts,
+    ];
+    return new web3_js_1.TransactionInstruction({ keys, programId, data });
+}
+// ---------------------------------------------------------------------------
+// init_or_update_hedge_state — ADMIN-gated (config.admin, NOT `require_manager`). Provisions or
+// updates the singleton `HedgeState` PDA (seeds `["hedge", config]`) every manager op above reads.
+// Not part of the manager-facing hedge-op family, but lives here (rather than instructions.ts) to
+// keep every hedge-shaped builder + its account-order doc together in one module.
+//
+// Verified against `instructions/hedge/init_or_update_hedge_state.rs`:
+//   - `#[derive(Accounts)] pub struct InitOrUpdateHedgeState<'info>` (5 fixed accounts)
+//   - `InitOrUpdateHedgeStateParams` (Borsh field order)
+//
+// Fixed accounts (5):
+//   0. payer            [signer, writable]  rent payer; must equal JlpdConfig.admin (both init+update)
+//   1. config             []                JlpdConfig PDA (already initialized; read-only — this ix
+//                                            never writes it)
+//   2. hedge_state      [writable]          HedgeState PDA, seeds ["hedge", config] (init_if_needed)
+//   3. token_program       []               validates/derives every canonical manifest ATA
+//   4. system_program      []               account creation on init
+//
+// remaining_accounts: 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).
+//
+// Instruction data: [8-byte disc, Borsh(InitOrUpdateHedgeStateParams)]
+// Borsh field order (Option-per-field; `None` keeps the stored value on update / a fail-closed
+// default on init):
+//   positions:                    [Option<HedgePositionSlotParams>; MAX_HEDGE_POSITIONS(4)]
+//     each HedgePositionSlotParams (Some case) = 5 Pubkeys in order:
+//       borrow_position, vault_config, vault_state, fluid_oracle, debt_mint
+//   jupusd / jupsol / wbtc / weth / wsol:           Option<Pubkey>  (5) — config-owned ATA manifest
+//   jl_jupusd / jl_wbtc / jl_weth:                  Option<Pubkey>  (3) — Earn fToken ATAs
+//   jl_jupusd_mint / jl_wbtc_mint / jl_weth_mint:   Option<Pubkey>  (3) — admin-set fToken mints
+//   jl_jupusd_lending / jl_wbtc_lending / jl_weth_lending: Option<Pubkey> (3) — Earn rate sources
+//   max_pledged_collateral_jlp:   Option<u64>
+//   max_swap_notional_per_settle: Option<u64>
+//   max_ltv_bps:                  Option<u16>
+//   enabled:                      Option<bool>
+// ---------------------------------------------------------------------------
+// sha256("global:init_or_update_hedge_state")[..8]. Defined locally rather than re-exported from
+// `constants.ts` (this SDK task's touch-scope is limited to this file/index.ts/the parity test) —
+// verified by an independent Node `crypto` computation in `__tests__/abi-parity.test.ts` and
+// matches the identical hardcoded constant the two jlpd-server setup scripts each carry.
+const IX_INIT_OR_UPDATE_HEDGE_STATE = Buffer.from([126, 123, 249, 65, 182, 100, 250, 254]);
+/** Serialize `Option<HedgePositionSlotParams>` — 1-byte tag, then 5 Pubkeys (160 bytes) if `Some`. */
+function writeOptionalHedgePositionSlot(parts, slot) {
+    if (slot != null) {
+        parts.push(0x01);
+        parts.push(...slot.borrowPosition.toBuffer());
+        parts.push(...slot.vaultConfig.toBuffer());
+        parts.push(...slot.vaultState.toBuffer());
+        parts.push(...slot.fluidOracle.toBuffer());
+        parts.push(...slot.debtMint.toBuffer());
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+/** Serialize `Option<bool>` — 1-byte tag, then 1 byte (0/1) if `Some`. */
+function writeOptionalBool(parts, value) {
+    if (value != null) {
+        parts.push(0x01);
+        parts.push(value ? 1 : 0);
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+/**
+ * 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.
+ */
+function createInitOrUpdateHedgeStateIx(args, programId = constants_1.PROGRAM_ID) {
+    const { payer, config, hedgeState, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, systemProgram = web3_js_1.SystemProgram.programId, positions = [], remainingAccounts = [], } = args;
+    if (positions.length !== 0 && positions.length !== constants_1.MAX_HEDGE_POSITIONS) {
+        throw new RangeError(`createInitOrUpdateHedgeStateIx: positions must have exactly ${constants_1.MAX_HEDGE_POSITIONS} entries ` +
+            `(or be omitted/empty to leave every slot untouched), got ${positions.length}`);
+    }
+    if (args.maxLtvBps != null &&
+        (!Number.isInteger(args.maxLtvBps) || args.maxLtvBps < 0 || args.maxLtvBps > constants_1.MAX_HEDGE_LTV_BPS)) {
+        throw new RangeError(`createInitOrUpdateHedgeStateIx: maxLtvBps must be an integer in 0..${constants_1.MAX_HEDGE_LTV_BPS}, got ${args.maxLtvBps}`);
+    }
+    const parts = [...IX_INIT_OR_UPDATE_HEDGE_STATE];
+    // positions: [Option<HedgePositionSlotParams>; MAX_HEDGE_POSITIONS] — a fixed-size Rust array,
+    // so the wire format is always exactly MAX_HEDGE_POSITIONS Option tags, no length prefix.
+    const slots = positions.length === constants_1.MAX_HEDGE_POSITIONS ? positions : new Array(constants_1.MAX_HEDGE_POSITIONS).fill(null);
+    for (const slot of slots)
+        writeOptionalHedgePositionSlot(parts, slot);
+    // Config-owned ATA manifest (5 Option<Pubkey>, Rust field order).
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jupusd ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jupsol ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.wbtc ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.weth ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.wsol ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlJupusd ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWbtc ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWeth ?? null);
+    // Admin-set Earn fToken mints (3 Option<Pubkey>).
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlJupusdMint ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWbtcMint ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWethMint ?? null);
+    // Earn rate sources (3 Option<Pubkey>).
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlJupusdLending ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWbtcLending ?? null);
+    (0, buffer_1.writeOptionalPubkey)(parts, args.jlWethLending ?? null);
+    // Guards.
+    (0, buffer_1.writeOptionalU64)(parts, args.maxPledgedCollateralJlp != null ? new bn_js_1.default(toBigIntAmount(args.maxPledgedCollateralJlp).toString()) : null);
+    (0, buffer_1.writeOptionalU64)(parts, args.maxSwapNotionalPerSettle != null ? new bn_js_1.default(toBigIntAmount(args.maxSwapNotionalPerSettle).toString()) : null);
+    (0, buffer_1.writeOptionalU16)(parts, args.maxLtvBps ?? null);
+    writeOptionalBool(parts, args.enabled ?? null);
+    const data = Buffer.from(parts);
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: config, isSigner: false, isWritable: false },
+        { pubkey: hedgeState, isSigner: false, isWritable: true },
+        { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ...remainingAccounts,
+    ];
+    return new web3_js_1.TransactionInstruction({ keys, programId, data });
+}

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

@@ -0,0 +1,88 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import type { SolanaConnection } from "../common/connection";
+/**
+ * One Fluid borrow position: the position NFT, that vault's pinned
+ * `VaultConfig`/`VaultState`/oracle, and its `debt_mint`. All-`PublicKey.default()`
+ * = disabled (see `isHedgePositionSlotDisabled`).
+ */
+export interface HedgePositionSlot {
+    /** This fund's Fluid position NFT account in that vault. */
+    borrowPosition: PublicKey;
+    /** That vault's `VaultConfig` account (pinned). */
+    vaultConfig: PublicKey;
+    /** That vault's `VaultState` account. */
+    vaultState: PublicKey;
+    /** That vault's own oracle account (pinned). */
+    fluidOracle: PublicKey;
+    /** Which asset this vault's debt side borrows (JupUSD long leg; SOL/wBTC/wETH short legs). */
+    debtMint: PublicKey;
+}
+/** A slot with every field at its fail-closed default — the only valid "off" state. */
+export declare function isHedgePositionSlotDisabled(slot: HedgePositionSlot): boolean;
+/** Is `mint` one of the Fluid debt mints a `HedgePositionSlot` may borrow? */
+export declare function isKnownHedgeDebtMint(mint: PublicKey): boolean;
+/**
+ * The shared Jup-Lend hedge positions, the config-owned token manifest, and
+ * the on-chain risk guards. Total 1256 bytes (8-byte discriminator + 1248
+ * data bytes).
+ */
+export interface HedgeState {
+    /** Up to `MAX_HEDGE_POSITIONS` independent Fluid borrow positions. */
+    positions: HedgePositionSlot[];
+    /** Free JupUSD working ATA (long-leg borrow destination / short-leg swap source). */
+    jupusd: PublicKey;
+    /** Free JupSOL working ATA (long-SOL exposure). */
+    jupsol: PublicKey;
+    /** Free raw wBTC working ATA. */
+    wbtc: PublicKey;
+    /** Free raw wETH working ATA. */
+    weth: PublicKey;
+    /** Free wSOL working ATA (short-leg borrowed SOL, pre-swap). */
+    wsol: PublicKey;
+    /** Jupiter Lend Earn jlJupUSD fToken ATA (short-leg earn parking). */
+    jlJupusd: PublicKey;
+    /** Jupiter Lend Earn jlwBTC fToken ATA (disabled until `jlWbtcMint` is set). */
+    jlWbtc: PublicKey;
+    /** Jupiter Lend Earn jlwETH fToken ATA (disabled until `jlWethMint` is set). */
+    jlWeth: PublicKey;
+    jlJupusdMint: PublicKey;
+    jlWbtcMint: PublicKey;
+    jlWethMint: PublicKey;
+    /** Canonical Jup-Lend Earn `lending` account for the JupUSD pool (`exchange_rate@115` values `jlJupusd`). */
+    jlJupusdLending: PublicKey;
+    /** Canonical `lending` account for the wBTC pool (disabled until `jlWbtcMint` is set). */
+    jlWbtcLending: PublicKey;
+    /** Canonical `lending` account for the wETH pool (disabled until `jlWethMint` is set). */
+    jlWethLending: PublicKey;
+    /** Max JLP (base units) that may be pledged as Fluid collateral, summed across every enabled slot. */
+    maxPledgedCollateralJlp: BN;
+    /** Swap-churn budget: max input notional (USD, 6-dec) `hedge_swap` may spend between settles. */
+    maxSwapNotionalPerSettle: BN;
+    /** Swap-churn accumulator: input notional spent since the last settle. Reset only by `settle_yield`. */
+    swapNotionalSinceSettle: BN;
+    /** Liquidation-probability cap in basis points, valued on each position's own pinned Fluid oracle. */
+    maxLtvBps: number;
+    /** Hedge switch bitfield; bit 0 (`HEDGE_FLAG_ENABLED`) is the master switch. */
+    flags: number;
+    /** Account version for migrations. 0 = uninitialized. */
+    version: number;
+    /** PDA bump seed. */
+    bump: number;
+}
+/** The hedge master switch: `flags` bit 0 (`HEDGE_FLAG_ENABLED`) — mirrors `HedgeState::is_enabled`. */
+export declare function isHedgeEnabled(state: Pick<HedgeState, "flags">): boolean;
+/** Derive the singleton `HedgeState` PDA. Seeds: ["hedge", config]. */
+export declare function findHedgeStatePda(config: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * Deserialize a `HedgeState` account buffer. Layout (offsets include the
+ * 8-byte Anchor discriminator) — see this module's `HedgeState` doc comment
+ * for the full field map; verified against
+ * `hedge_state.rs::test_hedge_state_field_offsets`.
+ */
+export declare function deserializeHedgeState(data: Buffer): HedgeState;
+/**
+ * Fetch + decode the singleton `HedgeState` account. `config` defaults to the
+ * derived JlpdConfig PDA (the only config this program has).
+ */
+export declare function fetchHedgeState(connection: SolanaConnection, config?: PublicKey, programId?: PublicKey): Promise<HedgeState>;

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHedgePositionSlotDisabled = isHedgePositionSlotDisabled;
+exports.isKnownHedgeDebtMint = isKnownHedgeDebtMint;
+exports.isHedgeEnabled = isHedgeEnabled;
+exports.findHedgeStatePda = findHedgeStatePda;
+exports.deserializeHedgeState = deserializeHedgeState;
+exports.fetchHedgeState = fetchHedgeState;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("../common/buffer");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+/** A slot with every field at its fail-closed default — the only valid "off" state. */
+function isHedgePositionSlotDisabled(slot) {
+    return (slot.borrowPosition.equals(web3_js_1.PublicKey.default) &&
+        slot.vaultConfig.equals(web3_js_1.PublicKey.default) &&
+        slot.vaultState.equals(web3_js_1.PublicKey.default) &&
+        slot.fluidOracle.equals(web3_js_1.PublicKey.default) &&
+        slot.debtMint.equals(web3_js_1.PublicKey.default));
+}
+/** Is `mint` one of the Fluid debt mints a `HedgePositionSlot` may borrow? */
+function isKnownHedgeDebtMint(mint) {
+    return (mint.equals(constants_1.MINT_JUPUSD) ||
+        mint.equals(constants_1.MINT_WSOL) ||
+        mint.equals(constants_1.MINT_WBTC) ||
+        mint.equals(constants_1.MINT_WETH));
+}
+/** The hedge master switch: `flags` bit 0 (`HEDGE_FLAG_ENABLED`) — mirrors `HedgeState::is_enabled`. */
+function isHedgeEnabled(state) {
+    return (state.flags & constants_1.HEDGE_FLAG_ENABLED) !== 0;
+}
+// ---------------------------------------------------------------------------
+// PDA derivation
+// ---------------------------------------------------------------------------
+/** Derive the singleton `HedgeState` PDA. Seeds: ["hedge", config]. */
+function findHedgeStatePda(config, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.HEDGE_STATE_SEED, config.toBuffer()], programId);
+}
+// ---------------------------------------------------------------------------
+// Deserialization
+// ---------------------------------------------------------------------------
+function deserializeHedgePositionSlot(data, offset) {
+    return {
+        borrowPosition: (0, buffer_1.readPubkey)(data, offset),
+        vaultConfig: (0, buffer_1.readPubkey)(data, offset + 32),
+        vaultState: (0, buffer_1.readPubkey)(data, offset + 64),
+        fluidOracle: (0, buffer_1.readPubkey)(data, offset + 96),
+        debtMint: (0, buffer_1.readPubkey)(data, offset + 128),
+    };
+}
+/**
+ * Deserialize a `HedgeState` account buffer. Layout (offsets include the
+ * 8-byte Anchor discriminator) — see this module's `HedgeState` doc comment
+ * for the full field map; verified against
+ * `hedge_state.rs::test_hedge_state_field_offsets`.
+ */
+function deserializeHedgeState(data) {
+    if (data.length < constants_1.HEDGE_STATE_SIZE) {
+        throw new Error(`HedgeState data too short: ${data.length} < ${constants_1.HEDGE_STATE_SIZE}`);
+    }
+    const disc = data.subarray(0, 8);
+    if (!disc.equals(constants_1.DISC_HEDGE_STATE)) {
+        throw new Error("Invalid HedgeState discriminator");
+    }
+    // positions[MAX_HEDGE_POSITIONS], starting right after the 8-byte discriminator.
+    const positions = [];
+    for (let i = 0; i < constants_1.MAX_HEDGE_POSITIONS; i++) {
+        positions.push(deserializeHedgePositionSlot(data, 8 + i * constants_1.HEDGE_POSITION_SLOT_SIZE));
+    }
+    const afterPositions = 8 + constants_1.MAX_HEDGE_POSITIONS * constants_1.HEDGE_POSITION_SLOT_SIZE; // 648
+    return {
+        positions,
+        jupusd: (0, buffer_1.readPubkey)(data, afterPositions),
+        jupsol: (0, buffer_1.readPubkey)(data, afterPositions + 32),
+        wbtc: (0, buffer_1.readPubkey)(data, afterPositions + 64),
+        weth: (0, buffer_1.readPubkey)(data, afterPositions + 96),
+        wsol: (0, buffer_1.readPubkey)(data, afterPositions + 128),
+        jlJupusd: (0, buffer_1.readPubkey)(data, afterPositions + 160),
+        jlWbtc: (0, buffer_1.readPubkey)(data, afterPositions + 192),
+        jlWeth: (0, buffer_1.readPubkey)(data, afterPositions + 224),
+        jlJupusdMint: (0, buffer_1.readPubkey)(data, afterPositions + 256),
+        jlWbtcMint: (0, buffer_1.readPubkey)(data, afterPositions + 288),
+        jlWethMint: (0, buffer_1.readPubkey)(data, afterPositions + 320),
+        jlJupusdLending: (0, buffer_1.readPubkey)(data, afterPositions + 352),
+        jlWbtcLending: (0, buffer_1.readPubkey)(data, afterPositions + 384),
+        jlWethLending: (0, buffer_1.readPubkey)(data, afterPositions + 416),
+        maxPledgedCollateralJlp: (0, buffer_1.readU64)(data, afterPositions + 448),
+        maxSwapNotionalPerSettle: (0, buffer_1.readU64)(data, afterPositions + 456),
+        swapNotionalSinceSettle: (0, buffer_1.readU64)(data, afterPositions + 464),
+        maxLtvBps: (0, buffer_1.readU16)(data, afterPositions + 472),
+        flags: (0, buffer_1.readU16)(data, afterPositions + 474),
+        version: (0, buffer_1.readU8)(data, afterPositions + 476),
+        bump: (0, buffer_1.readU8)(data, afterPositions + 477),
+    };
+}
+// ---------------------------------------------------------------------------
+// Fetch helper
+// ---------------------------------------------------------------------------
+/**
+ * Fetch + decode the singleton `HedgeState` account. `config` defaults to the
+ * derived JlpdConfig PDA (the only config this program has).
+ */
+async function fetchHedgeState(connection, config, programId = constants_1.PROGRAM_ID) {
+    const configKey = config ?? (0, pda_1.findJlpdConfigPda)(programId)[0];
+    const [pda] = findHedgeStatePda(configKey, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info)
+        throw new Error("HedgeState account not found");
+    return deserializeHedgeState(info.data);
+}

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

@@ -0,0 +1,17 @@
+export * from "./constants";
+export * from "./types";
+export * from "./pda";
+export * from "./accounts";
+export * from "./instructions";
+export * from "./swap-jlp";
+export * from "./base-to-base-swap";
+export * from "./settle-yield";
+export * from "./jlp-data";
+export * from "./jlp-borrow";
+export * from "./jupusd-earn";
+export * from "./adapter";
+export * from "./hedge-state";
+export * from "./hedge-instructions";
+export * from "./fluid-view";
+export * from "./hedge-derived";
+export * from "./live-jlp-price";

package/dist/jlpd-strategy/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./pda"), exports);
+__exportStar(require("./accounts"), exports);
+__exportStar(require("./instructions"), exports);
+__exportStar(require("./swap-jlp"), exports);
+__exportStar(require("./base-to-base-swap"), exports);
+__exportStar(require("./settle-yield"), exports);
+__exportStar(require("./jlp-data"), exports);
+__exportStar(require("./jlp-borrow"), exports);
+__exportStar(require("./jupusd-earn"), exports);
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./hedge-state"), exports);
+__exportStar(require("./hedge-instructions"), exports);
+__exportStar(require("./fluid-view"), exports);
+__exportStar(require("./hedge-derived"), exports);
+__exportStar(require("./live-jlp-price"), exports);