@elmntl/jlpd-sdk 0.1.9 → 0.2.0

package/dist/index.js

@@ -28,10 +28,12 @@ __export(index_exports, {
   FLAG_REBALANCE_DISABLED: () => FLAG_REBALANCE_DISABLED,
   FLAG_WITHDRAWALS_DISABLED: () => FLAG_WITHDRAWALS_DISABLED,
   JLPD_PROGRAM_ID: () => JLPD_PROGRAM_ID,
+  JLP_POOL_PUBKEY: () => JLP_POOL_PUBKEY,
   JLP_VAULT_ACCOUNT_SIZE: () => JLP_VAULT_ACCOUNT_SIZE,
   JLP_VAULT_DATA_SIZE: () => JLP_VAULT_DATA_SIZE,
   JLP_VAULT_DISCRIMINATOR: () => JLP_VAULT_DISCRIMINATOR,
   JUPITER_LEND_PROGRAM_ID: () => JUPITER_LEND_PROGRAM_ID,
+  JUPITER_PERPS_PROGRAM_ID: () => JUPITER_PERPS_PROGRAM_ID,
   JUPITER_SWAP_PROGRAM_ID: () => JUPITER_SWAP_PROGRAM_ID,
   JUPUSD_POOL: () => JUPUSD_POOL,
   JUP_LEND_PROGRAM_ID: () => JUPITER_LEND_PROGRAM_ID2,
@@ -47,6 +49,7 @@ __export(index_exports, {
   PoolContext: () => PoolContext,
   SEED_JLP_VAULT: () => SEED_JLP_VAULT,
   SEED_STV: () => SEED_STV,
+  SEED_WITHDRAW_REQUEST: () => SEED_WITHDRAW_REQUEST,
   STV_ACCOUNT_SIZE: () => STV_ACCOUNT_SIZE,
   STV_DATA_SIZE: () => STV_DATA_SIZE,
   STV_DISCRIMINATOR: () => STV_DISCRIMINATOR,
@@ -55,6 +58,9 @@ __export(index_exports, {
   USDC_POOL: () => USDC_POOL,
   WBTC_POOL: () => WBTC_POOL,
   WETH_POOL: () => WETH_POOL,
+  WITHDRAW_REQUEST_ACCOUNT_SIZE: () => WITHDRAW_REQUEST_ACCOUNT_SIZE,
+  WITHDRAW_REQUEST_DATA_SIZE: () => WITHDRAW_REQUEST_DATA_SIZE,
+  WITHDRAW_REQUEST_DISCRIMINATOR: () => WITHDRAW_REQUEST_DISCRIMINATOR,
   WSOL_POOL: () => WSOL_POOL,
   baseToJlx: () => baseToJlx,
   baseToShares: () => baseToShares,
@@ -68,23 +74,25 @@ __export(index_exports, {
   clearAtaCache: () => clearAtaCache,
   clearPdaCache: () => clearPdaCache,
   createClaimFeesInstruction: () => createClaimFeesInstruction,
+  createClaimWithdrawInstruction: () => createClaimWithdrawInstruction,
   createDepositInstruction: () => createDepositInstruction,
   createInitOrUpdateVaultInstruction: () => createInitOrUpdateVaultInstruction,
   createInitializeStvInstruction: () => createInitializeStvInstruction,
   createJupEarnInstruction: () => createJupEarnInstruction,
   createMoveJlxInstruction: () => createMoveJlxInstruction,
+  createProcessEpochInstruction: () => createProcessEpochInstruction,
   createProgram: () => createProgram,
+  createRequestWithdrawInstruction: () => createRequestWithdrawInstruction,
   createSettleYieldInstruction: () => createSettleYieldInstruction,
   createSwapJlxJlpInstruction: () => createSwapJlxJlpInstruction,
-  createSwapJlxJlxInstruction: () => createSwapJlxJlxInstruction,
   createUpdateStvInstruction: () => createUpdateStvInstruction,
-  createWithdrawInstruction: () => createWithdrawInstruction,
   deriveAta: () => deriveAta,
   deriveStvAtas: () => deriveStvAtas,
   deriveStvPda: () => deriveStvPda,
   deriveUserAtas: () => deriveUserAtas,
   deriveVaultAtas: () => deriveVaultAtas,
   deriveVaultPda: () => deriveVaultPda,
+  deriveWithdrawRequestPda: () => deriveWithdrawRequestPda,
   fetchAddressLookupTables: () => fetchAddressLookupTables,
   fetchJlpRate: () => fetchJlpRate,
   fetchJupiterPriceUsd: () => fetchJupiterPriceUsd,
@@ -98,6 +106,7 @@ __export(index_exports, {
   parseStv: () => parseStv,
   parseSwapRemainingAccounts: () => parseSwapRemainingAccounts,
   parseVault: () => parseVault,
+  parseWithdrawRequest: () => parseWithdrawRequest,
   sharesToBase: () => sharesToBase
 });
 module.exports = __toCommonJS(index_exports);
@@ -204,66 +213,71 @@ var jlp_d_program_default = {
       args: []
     },
     {
-      name: "close_stv",
+      name: "claim_withdraw",
       docs: [
-        "Close an STV account and return rent to admin",
-        "Destructive operation - use only for cleanup/migration",
+        "Claim processed withdrawal (epoch-based delayed withdrawal)",
         "",
-        "# Safety Checks",
-        "- Validates jvX supply is 0 (no active shares)",
-        "- Validates base_loaned is 0 (no outstanding loans)",
-        "- Validates accrued_fees_jlx is 0 (no unclaimed fees)"
+        "# Flow",
+        "1. Verify request is processed (pps > 0) and claim period reached",
+        "2. Transfer base from STV to user",
+        "3. Close request's jvX ATA and WithdrawRequest PDA (rent to user)"
       ],
       discriminator: [
-        173,
-        189,
-        151,
-        131,
-        240,
-        39,
-        199,
-        147
+        232,
+        89,
+        154,
+        117,
+        16,
+        204,
+        182,
+        224
       ],
       accounts: [
         {
-          name: "admin",
+          name: "user",
           docs: [
-            "Admin must sign - verified via vault.has_one = admin"
+            "User claiming their withdrawal"
           ],
           writable: true,
-          signer: true,
-          relations: [
-            "jlp_vault"
+          signer: true
+        },
+        {
+          name: "stv",
+          docs: [
+            "The STV PDA account (mut for reserved_base update)"
+          ],
+          writable: true
+        },
+        {
+          name: "base_mint",
+          docs: [
+            "Base asset mint (for transfer_checked)"
           ]
         },
         {
-          name: "jlp_vault",
+          name: "jv_mint",
           docs: [
-            "JLP Vault for admin validation"
+            "jvX mint (for ATA close verification)"
+          ]
+        },
+        {
+          name: "user_base_ata",
+          docs: [
+            "User's base token destination"
           ],
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  106,
-                  108,
-                  112,
-                  95,
-                  118,
-                  97,
-                  117,
-                  108,
-                  116
-                ]
-              }
-            ]
-          }
+          writable: true
         },
         {
-          name: "stv",
+          name: "stv_base_ata",
+          docs: [
+            "STV's base ATA (source for base transfer)"
+          ],
+          writable: true
+        },
+        {
+          name: "withdraw_request",
           docs: [
-            "STV to close"
+            "WithdrawRequest PDA - closed after claim (rent to user)"
           ],
           writable: true,
           pda: {
@@ -271,33 +285,49 @@ var jlp_d_program_default = {
               {
                 kind: "const",
                 value: [
-                  115,
+                  119,
+                  105,
                   116,
-                  118
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  114,
+                  101,
+                  113,
+                  117,
+                  101,
+                  115,
+                  116
                 ]
               },
               {
                 kind: "account",
-                path: "base_mint"
+                path: "stv"
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "withdraw_request.epoch_id",
+                account: "WithdrawRequest"
               }
             ]
           }
         },
         {
-          name: "jv_mint",
+          name: "request_jvx_ata",
           docs: [
-            "jvX mint for this STV - used to verify no active shares"
-          ]
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint for this STV"
-          ]
+            "Empty jvX ATA owned by WithdrawRequest PDA (to close, rent to user)"
+          ],
+          writable: true
         },
         {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
+          name: "token_program"
         }
       ],
       args: []
@@ -559,7 +589,7 @@ var jlp_d_program_default = {
           name: "jv_mint",
           docs: [
             "Vault share token mint (jvX) - STV is the mint authority",
-            "Client generates keypair and passes it as signer"
+            "Uses init_if_needed in case mint exists from a previous STV initialization"
           ],
           writable: true,
           signer: true
@@ -891,6 +921,305 @@ var jlp_d_program_default = {
         }
       ]
     },
+    {
+      name: "process_epoch",
+      docs: [
+        "Process epoch: burn jvX from withdraw requests, record PPS, earmark base",
+        "",
+        "Permissionless (anyone can call after epoch ends).",
+        "Processes WithdrawRequest pairs from remaining_accounts.",
+        "Uses epoch_pps for multi-batch consistency.",
+        "",
+        "# Remaining Accounts",
+        "- [0-1]: Jupiter Lend accounts (if jl_mint != base_mint)",
+        "- [N..]: pairs of [WithdrawRequest (mut), request_jvx_ata (mut)]"
+      ],
+      discriminator: [
+        115,
+        194,
+        215,
+        160,
+        113,
+        154,
+        81,
+        5
+      ],
+      accounts: [
+        {
+          name: "payer",
+          docs: [
+            "Payer/caller - permissionless (anyone can call after epoch ends)"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "jlp_vault",
+          docs: [
+            "The JLP Vault PDA account (for pause checks)"
+          ]
+        },
+        {
+          name: "stv",
+          docs: [
+            "The STV PDA account (mut for epoch state + fee crystallization)"
+          ],
+          writable: true
+        },
+        {
+          name: "base_mint",
+          docs: [
+            "Base asset mint (for NAV calc)"
+          ]
+        },
+        {
+          name: "jl_mint",
+          docs: [
+            "jlX mint (for exchange rate)"
+          ]
+        },
+        {
+          name: "jv_mint",
+          docs: [
+            "jvX mint (mut for burn - supply decreases)"
+          ],
+          writable: true
+        },
+        {
+          name: "stv_base_ata",
+          docs: [
+            "STV's base ATA (for NAV)"
+          ]
+        },
+        {
+          name: "stv_jlx_ata",
+          docs: [
+            "STV's jlX ATA (for NAV)"
+          ]
+        },
+        {
+          name: "token_program"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "request_withdraw",
+      docs: [
+        "Request withdrawal of jvX shares (epoch-based delayed withdrawal)",
+        "",
+        "# Flow",
+        "1. Validate epoch is active and not ended",
+        "2. Create or accumulate into WithdrawRequest PDA for this epoch",
+        "3. Transfer jvX from user to request's escrow ATA",
+        "",
+        "User must wait for process_epoch + claim_withdraw to receive base."
+      ],
+      discriminator: [
+        137,
+        95,
+        187,
+        96,
+        250,
+        138,
+        31,
+        182
+      ],
+      accounts: [
+        {
+          name: "user",
+          docs: [
+            "User requesting withdrawal"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "jlp_vault",
+          docs: [
+            "The JLP Vault PDA account (for pause checks)"
+          ]
+        },
+        {
+          name: "stv",
+          docs: [
+            "The STV PDA account (for epoch validation)"
+          ],
+          writable: true
+        },
+        {
+          name: "jv_mint",
+          docs: [
+            "jvX mint (vault share token)"
+          ]
+        },
+        {
+          name: "user_jvx_ata",
+          docs: [
+            "User's jvX token account (source of shares)"
+          ],
+          writable: true
+        },
+        {
+          name: "withdraw_request",
+          docs: [
+            "WithdrawRequest PDA - created or accumulated into"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  114,
+                  101,
+                  113,
+                  117,
+                  101,
+                  115,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "stv"
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "arg",
+                path: "epoch_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "request_jvx_ata",
+          docs: [
+            "jvX ATA owned by the WithdrawRequest PDA (escrow for shares)"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "withdraw_request"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "jv_mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "shares",
+          type: "u64"
+        },
+        {
+          name: "epoch_id",
+          type: "u32"
+        }
+      ]
+    },
     {
       name: "settle_yield",
       docs: [
@@ -902,17 +1231,15 @@ var jlp_d_program_default = {
         "2. Values total base_loaned across all STVs in USD",
         "3. Distributes surplus (yield) or deficit (bad debt) proportionally",
         "",
-        "# Parameters",
-        "- `jlp_rate`: Manager-provided JLP price (8 decimals), cross-checked against Pyth",
-        "",
         "# Security",
         "- BTC/ETH/SOL prices come from Doves oracles (manipulation-resistant)",
-        "- JLP price from Pyth oracle, validated against manager rate (50 bps tolerance)",
+        "- JLP price computed directly from Jupiter Perps Pool account (aumUsd / jlp_supply)",
         "- Exchange rates come from Jupiter Earn (audited, TWAP-based)",
         "- Distribution is proportional to each STV's share of total loans",
         "",
         "# Accounts",
-        "Requires all 5 STVs, 5 staging jlX ATAs, 3 Doves oracles (BTC/ETH/SOL), 1 Pyth oracle (JLP)",
+        "Requires all 5 STVs, 5 staging jlX ATAs, 3 Doves oracles (BTC/ETH/SOL),",
+        "Jupiter Perps Pool account, JLP mint account",
         "",
         "# Remaining Accounts (15 accounts)",
         "For exchange rate calculation with time-accrued rewards:",
@@ -986,7 +1313,10 @@ var jlp_d_program_default = {
           name: "doves_sol_usd"
         },
         {
-          name: "pyth_jlp_usd"
+          name: "jlp_pool"
+        },
+        {
+          name: "jlp_mint_account"
         },
         {
           name: "manager",
@@ -996,16 +1326,7 @@ var jlp_d_program_default = {
           signer: true
         }
       ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "SettleYieldParams"
-            }
-          }
-        }
-      ]
+      args: []
     },
     {
       name: "swap_jlx_to_from_jlp",
@@ -1145,121 +1466,6 @@ var jlp_d_program_default = {
           }
         }
       ]
-    },
-    {
-      name: "withdraw",
-      docs: [
-        "Withdraw base asset by burning jvX shares",
-        "",
-        "# Flow",
-        "1. Crystallize fees inline (ensures fair PPS)",
-        "2. Calculate base amount from shares at post-fee PPS",
-        "3. Burn jvX shares from user",
-        "4. Transfer base from STV's base ATA to user",
-        "",
-        "# Note",
-        "Requires sufficient base balance in STV's base ATA.",
-        "Manager must ensure liquidity by converting jlX to base via",
-        "jup_earn_deposit_withdraw instruction before user withdrawals.",
-        "",
-        "Remaining accounts (optional, for exchange rate):",
-        "[0] = Jupiter Lend lending account",
-        "[1] = Jupiter Lend rewards rate model"
-      ],
-      discriminator: [
-        183,
-        18,
-        70,
-        156,
-        148,
-        109,
-        161,
-        34
-      ],
-      accounts: [
-        {
-          name: "user",
-          docs: [
-            "User performing the withdrawal"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (underlying token: SOL, BTC, ETH, USDC)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (Jupiter Lend token) - used for NAV calculation"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint (vault share token) - STV is mint authority",
-            "Verified against STV.jv_mint in handler"
-          ],
-          writable: true
-        },
-        {
-          name: "user_base_ata",
-          docs: [
-            "User's base asset token account (destination for withdrawal)"
-          ],
-          writable: true
-        },
-        {
-          name: "user_jvx_ata",
-          docs: [
-            "User's jvX token account (source - shares to burn)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (source for base tokens to user)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (used for NAV calculation)"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "shares_to_burn",
-          type: "u64"
-        }
-      ]
     }
   ],
   accounts: [
@@ -1288,6 +1494,19 @@ var jlp_d_program_default = {
         17,
         230
       ]
+    },
+    {
+      name: "WithdrawRequest",
+      discriminator: [
+        186,
+        239,
+        174,
+        191,
+        189,
+        13,
+        47,
+        196
+      ]
     }
   ],
   events: [
@@ -1304,6 +1523,32 @@ var jlp_d_program_default = {
         57
       ]
     },
+    {
+      name: "EpochAdvanced",
+      discriminator: [
+        41,
+        220,
+        14,
+        123,
+        117,
+        70,
+        117,
+        157
+      ]
+    },
+    {
+      name: "EpochProcessed",
+      discriminator: [
+        18,
+        238,
+        2,
+        247,
+        238,
+        178,
+        94,
+        138
+      ]
+    },
     {
       name: "FeesClaimSkipped",
       discriminator: [
@@ -1474,16 +1719,29 @@ var jlp_d_program_default = {
       ]
     },
     {
-      name: "Withdrawn",
+      name: "WithdrawClaimed",
+      discriminator: [
+        77,
+        130,
+        89,
+        38,
+        239,
+        172,
+        174,
+        85
+      ]
+    },
+    {
+      name: "WithdrawRequested",
       discriminator: [
-        20,
-        89,
-        223,
-        198,
-        194,
-        124,
-        219,
-        13
+        114,
+        16,
+        240,
+        206,
+        93,
+        128,
+        151,
+        39
       ]
     }
   ],
@@ -1705,8 +1963,8 @@ var jlp_d_program_default = {
     },
     {
       code: 6043,
-      name: "JlpRateExceedsTolerance",
-      msg: "Manager JLP rate exceeds tolerance vs Pyth oracle (>50 bps)"
+      name: "JlpPriceOutOfRange",
+      msg: "JLP price out of reasonable range ($0.50 - $50.00)"
     },
     {
       code: 6044,
@@ -1717,6 +1975,56 @@ var jlp_d_program_default = {
       code: 6045,
       name: "NotAdmin",
       msg: "Unauthorized: not admin"
+    },
+    {
+      code: 6046,
+      name: "TokenAccountNotEmpty",
+      msg: "Token account balance must be zero before closing"
+    },
+    {
+      code: 6047,
+      name: "TokenAccountOwnerMismatch",
+      msg: "Token account not owned by expected PDA"
+    },
+    {
+      code: 6048,
+      name: "EpochEnded",
+      msg: "Epoch has ended - call process_epoch first"
+    },
+    {
+      code: 6049,
+      name: "EpochNotEnded",
+      msg: "Epoch has not ended yet"
+    },
+    {
+      code: 6050,
+      name: "ClaimNotAvailableYet",
+      msg: "Claim not available yet - wait for next epoch"
+    },
+    {
+      code: 6051,
+      name: "InvalidEpochInterval",
+      msg: "Withdraw epoch interval must be > 0"
+    },
+    {
+      code: 6052,
+      name: "ActiveWithdrawReserves",
+      msg: "Cannot update epoch interval with active reserves"
+    },
+    {
+      code: 6053,
+      name: "EpochIdMismatch",
+      msg: "Epoch ID mismatch"
+    },
+    {
+      code: 6054,
+      name: "WithdrawRequestNotProcessed",
+      msg: "Withdraw request not processed yet"
+    },
+    {
+      code: 6055,
+      name: "WithdrawRequestAlreadyProcessed",
+      msg: "Withdraw request already processed"
     }
   ],
   types: [
@@ -1768,6 +2076,62 @@ var jlp_d_program_default = {
         ]
       }
     },
+    {
+      name: "EpochAdvanced",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "stv",
+            type: "pubkey"
+          },
+          {
+            name: "new_epoch_id",
+            type: "u32"
+          },
+          {
+            name: "new_next_epoch_ts",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "EpochProcessed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "stv",
+            type: "pubkey"
+          },
+          {
+            name: "epoch_id",
+            type: "u32"
+          },
+          {
+            name: "pps",
+            type: "u64"
+          },
+          {
+            name: "total_shares",
+            type: "u64"
+          },
+          {
+            name: "total_base",
+            type: "u64"
+          },
+          {
+            name: "new_epoch_id",
+            type: "u32"
+          },
+          {
+            name: "new_next_epoch_ts",
+            type: "u32"
+          }
+        ]
+      }
+    },
     {
       name: "FeesClaimSkipped",
       docs: [
@@ -1953,6 +2317,13 @@ var jlp_d_program_default = {
               "Minimum deposit amount in base asset (0 = no minimum)"
             ],
             type: "u64"
+          },
+          {
+            name: "epoch_sec",
+            docs: [
+              "Epoch duration in seconds for delayed withdrawals"
+            ],
+            type: "u32"
           }
         ]
       }
@@ -2398,7 +2769,7 @@ var jlp_d_program_default = {
       docs: [
         "STV - Single Token Vault account",
         'Seeds: ["stv", base_mint.key().as_ref()]',
-        "Size: 8 (discriminator) + 160 (data) = 168 bytes"
+        "Size: 8 (discriminator) + 200 (data) = 208 bytes"
       ],
       serialization: "bytemuck",
       repr: {
@@ -2480,6 +2851,50 @@ var jlp_d_program_default = {
             ],
             type: "u64"
           },
+          {
+            name: "requested_base",
+            docs: [
+              "Estimated base for current epoch's withdrawal requests (reset on process_epoch)",
+              "Manager reads this to know how much to unwind before next epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "reserved_base",
+            docs: [
+              "Base earmarked for unclaimed withdrawals (+process_epoch, -claim_withdraw)",
+              "Subtracted from NAV so reserved funds don't inflate PPS"
+            ],
+            type: "u64"
+          },
+          {
+            name: "epoch_pps",
+            docs: [
+              "PPS locked at first process_epoch batch (0 = not set, reset on epoch advance)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "next_epoch_ts",
+            docs: [
+              "Unix timestamp when current epoch ends"
+            ],
+            type: "u32"
+          },
+          {
+            name: "epoch_sec",
+            docs: [
+              "Epoch duration in seconds"
+            ],
+            type: "u32"
+          },
+          {
+            name: "current_epoch_id",
+            docs: [
+              "Incrementing epoch counter"
+            ],
+            type: "u32"
+          },
           {
             name: "mgmt_fee_bps",
             docs: [
@@ -2514,6 +2929,18 @@ var jlp_d_program_default = {
               "PDA bump seed"
             ],
             type: "u8"
+          },
+          {
+            name: "_padding",
+            docs: [
+              "Alignment padding"
+            ],
+            type: {
+              array: [
+                "u8",
+                4
+              ]
+            }
           }
         ]
       }
@@ -2571,25 +2998,6 @@ var jlp_d_program_default = {
         ]
       }
     },
-    {
-      name: "SettleYieldParams",
-      docs: [
-        "Parameters for settle_yield instruction"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "jlp_rate",
-            docs: [
-              "Manager-provided JLP rate (8 decimals, e.g., 450000000 = $4.50)",
-              "Cross-checked against Pyth oracle, must be within 50 bps tolerance"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
     {
       name: "SettleYieldSkipped",
       docs: [
@@ -2761,120 +3169,253 @@ var jlp_d_program_default = {
             name: "JlxToJlp"
           },
           {
-            name: "JlpToJlx"
+            name: "JlpToJlx"
+          }
+        ]
+      }
+    },
+    {
+      name: "SwapJlxJlpParams",
+      docs: [
+        "Parameters for the swap instruction"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "stv_index",
+            docs: [
+              "Which STV this JLP belongs to (0-4: BTC, ETH, SOL, USDC, JupUSD)"
+            ],
+            type: "u8"
+          },
+          {
+            name: "direction",
+            docs: [
+              "Direction of the swap"
+            ],
+            type: {
+              defined: {
+                name: "SwapDirection"
+              }
+            }
+          },
+          {
+            name: "amount_in",
+            docs: [
+              "Amount of input token being swapped"
+            ],
+            type: "u64"
+          },
+          {
+            name: "expected_amount_out",
+            docs: [
+              "Expected output amount (used for devnet mock, verified on mainnet)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "jupiter_data",
+            docs: [
+              "Jupiter swap instruction data (includes discriminator and route)",
+              "This is obtained from Jupiter API off-chain",
+              "On devnet (with `devnet` feature), this can be empty"
+            ],
+            type: "bytes"
+          }
+        ]
+      }
+    },
+    {
+      name: "UpdateStvParams",
+      docs: [
+        "Parameters for updating an STV"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mgmt_fee_bps",
+            docs: [
+              "Management fee in basis points (annual)"
+            ],
+            type: "u16"
+          },
+          {
+            name: "perf_fee_bps",
+            docs: [
+              "Performance fee in basis points"
+            ],
+            type: "u16"
+          },
+          {
+            name: "flags",
+            docs: [
+              "STV state flags"
+            ],
+            type: "u16"
+          },
+          {
+            name: "max_deposit",
+            docs: [
+              "Maximum deposit amount in base asset (0 = unlimited)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "min_deposit",
+            docs: [
+              "Minimum deposit amount in base asset (0 = no minimum)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "jl_mint",
+            docs: [
+              "Optional new jl_mint for migrating base-only pools to Jupiter Lend"
+            ],
+            type: {
+              option: "pubkey"
+            }
+          },
+          {
+            name: "pps",
+            docs: [
+              "Override price per share (9 decimals, e.g. 1_000_000_000 = 1.0)"
+            ],
+            type: {
+              option: "u64"
+            }
+          },
+          {
+            name: "hwm",
+            docs: [
+              "Override high water mark (9 decimals)"
+            ],
+            type: {
+              option: "u64"
+            }
+          },
+          {
+            name: "base_loaned",
+            docs: [
+              "Override base_loaned accounting field"
+            ],
+            type: {
+              option: "u64"
+            }
+          },
+          {
+            name: "epoch_sec",
+            docs: [
+              "Optional new epoch duration in seconds"
+            ],
+            type: {
+              option: "u32"
+            }
           }
         ]
       }
     },
     {
-      name: "SwapJlxJlpParams",
-      docs: [
-        "Parameters for the swap instruction"
-      ],
+      name: "WithdrawClaimed",
       type: {
         kind: "struct",
         fields: [
           {
-            name: "stv_index",
-            docs: [
-              "Which STV this JLP belongs to (0-4: BTC, ETH, SOL, USDC, JupUSD)"
-            ],
-            type: "u8"
+            name: "stv",
+            type: "pubkey"
           },
           {
-            name: "direction",
-            docs: [
-              "Direction of the swap"
-            ],
-            type: {
-              defined: {
-                name: "SwapDirection"
-              }
-            }
+            name: "user",
+            type: "pubkey"
           },
           {
-            name: "amount_in",
-            docs: [
-              "Amount of input token being swapped"
-            ],
+            name: "shares",
             type: "u64"
           },
           {
-            name: "expected_amount_out",
-            docs: [
-              "Expected output amount (used for devnet mock, verified on mainnet)"
-            ],
+            name: "base_amount",
             type: "u64"
           },
           {
-            name: "jupiter_data",
-            docs: [
-              "Jupiter swap instruction data (includes discriminator and route)",
-              "This is obtained from Jupiter API off-chain",
-              "On devnet (with `devnet` feature), this can be empty"
-            ],
-            type: "bytes"
+            name: "epoch_id",
+            type: "u32"
           }
         ]
       }
     },
     {
-      name: "UpdateStvParams",
+      name: "WithdrawRequest",
       docs: [
-        "Parameters for updating an STV"
+        "WithdrawRequest - Per-user per-epoch withdrawal request",
+        'Seeds: ["withdraw_request", stv.key(), user.key(), &epoch_id.to_le_bytes()]',
+        "",
+        "One PDA per user per STV per epoch. Multiple request_withdraw calls",
+        "in the same epoch accumulate into the same PDA.",
+        "",
+        "Lifecycle:",
+        "1. Created by request_withdraw (user escrows jvX into request's ATA)",
+        "2. Processed by process_epoch (jvX burned, pps + claim_available_after set)",
+        "3. Closed by claim_withdraw (base transferred, PDA + ATA closed)"
       ],
       type: {
         kind: "struct",
         fields: [
           {
-            name: "mgmt_fee_bps",
+            name: "stv",
             docs: [
-              "Management fee in basis points (annual)"
+              "Back-reference to the STV"
             ],
-            type: "u16"
+            type: "pubkey"
           },
           {
-            name: "perf_fee_bps",
+            name: "user",
             docs: [
-              "Performance fee in basis points"
+              "The user who requested the withdrawal"
             ],
-            type: "u16"
+            type: "pubkey"
           },
           {
-            name: "flags",
+            name: "shares",
             docs: [
-              "STV state flags"
+              "Total jvX shares escrowed (accumulated across multiple requests in same epoch)"
             ],
-            type: "u16"
+            type: "u64"
           },
           {
-            name: "max_deposit",
+            name: "pps",
             docs: [
-              "Maximum deposit amount in base asset (0 = unlimited)"
+              "PPS at process time (0 = unprocessed)"
             ],
             type: "u64"
           },
           {
-            name: "min_deposit",
+            name: "epoch_id",
             docs: [
-              "Minimum deposit amount in base asset (0 = no minimum)"
+              "Epoch when request was made"
             ],
-            type: "u64"
+            type: "u32"
           },
           {
-            name: "jl_mint",
+            name: "claim_available_after",
             docs: [
-              "Optional new jl_mint for migrating base-only pools to Jupiter Lend"
+              "Unix timestamp after which claim is available (0 = unprocessed)"
             ],
-            type: {
-              option: "pubkey"
-            }
+            type: "u32"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA bump seed"
+            ],
+            type: "u8"
           }
         ]
       }
     },
     {
-      name: "Withdrawn",
+      name: "WithdrawRequested",
       type: {
         kind: "struct",
         fields: [
@@ -2887,19 +3428,16 @@ var jlp_d_program_default = {
             type: "pubkey"
           },
           {
-            name: "shares_burned",
+            name: "shares",
             type: "u64"
           },
           {
-            name: "amount_base",
-            docs: [
-              "Amount of base asset withdrawn"
-            ],
+            name: "total_shares",
             type: "u64"
           },
           {
-            name: "pps",
-            type: "u64"
+            name: "epoch_id",
+            type: "u32"
           }
         ]
       }
@@ -2934,6 +3472,7 @@ var JUPITER_SWAP_PROGRAM_ID = new import_web32.PublicKey(
 );
 var SEED_JLP_VAULT = "jlp_vault";
 var SEED_STV = "stv";
+var SEED_WITHDRAW_REQUEST = "withdraw_request";
 var FLAG_PAUSED = 1;
 var FLAG_DEPOSITS_DISABLED = 2;
 var FLAG_WITHDRAWALS_DISABLED = 4;
@@ -2961,15 +3500,16 @@ var ORACLES = {
   // Doves oracles (Jupiter Perps oracle system)
   DOVES_BTC_USD: new import_web32.PublicKey("4HBbPx9QJdjJ7GUe6bsiJjGybvfpDhQMMPXP1UEa7VT5"),
   DOVES_ETH_USD: new import_web32.PublicKey("5URYohbPy32nxK1t3jAHVNfdWY2xTubHiFvLrE3VhXEp"),
-  DOVES_SOL_USD: new import_web32.PublicKey("39cWjvHrpHNz2SbXv6ME4NPhqBDBd4KsjUYv5JkHEAJU"),
-  // Pyth oracle for JLP price
-  PYTH_JLP_USD: new import_web32.PublicKey("2TTGSRSezqFzeLUH8JwRUbtN66XLLaymfYsWRTMjfiMw")
+  DOVES_SOL_USD: new import_web32.PublicKey("39cWjvHrpHNz2SbXv6ME4NPhqBDBd4KsjUYv5JkHEAJU")
 };
+var JLP_POOL_PUBKEY = new import_web32.PublicKey("5BUwFW4nRbftYTDMbgxykoFWqWHPzahFSNAaaaJtVKsq");
+var JUPITER_PERPS_PROGRAM_ID = new import_web32.PublicKey("PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu");
 
 // src/accounts/pdas.ts
 var import_web33 = require("@solana/web3.js");
 var SEED_JLP_VAULT_BUFFER = Buffer.from(SEED_JLP_VAULT);
 var SEED_STV_BUFFER = Buffer.from(SEED_STV);
+var SEED_WITHDRAW_REQUEST_BUFFER = Buffer.from(SEED_WITHDRAW_REQUEST);
 var pdaCache = /* @__PURE__ */ new Map();
 function deriveVaultPda(programId) {
   const key = `vault:${programId.toBase58()}`;
@@ -2995,6 +3535,20 @@ function deriveStvPda(baseMint, programId) {
   }
   return cached;
 }
+function deriveWithdrawRequestPda(stvPda, user, epochId, programId) {
+  const key = `wr:${stvPda.toBase58()}:${user.toBase58()}:${epochId}:${programId.toBase58()}`;
+  let cached = pdaCache.get(key);
+  if (!cached) {
+    const epochIdBuffer = Buffer.alloc(4);
+    epochIdBuffer.writeUInt32LE(epochId);
+    cached = import_web33.PublicKey.findProgramAddressSync(
+      [SEED_WITHDRAW_REQUEST_BUFFER, stvPda.toBuffer(), user.toBuffer(), epochIdBuffer],
+      programId
+    );
+    pdaCache.set(key, cached);
+  }
+  return cached;
+}
 function clearPdaCache() {
   pdaCache.clear();
 }
@@ -3073,7 +3627,7 @@ function parseVault(data) {
 // src/accounts/stv.ts
 var import_web35 = require("@solana/web3.js");
 var import_anchor3 = require("@coral-xyz/anchor");
-var STV_DATA_SIZE = 160;
+var STV_DATA_SIZE = 200;
 var STV_ACCOUNT_SIZE = 8 + STV_DATA_SIZE;
 var STV_DISCRIMINATOR = Buffer.from([
   214,
@@ -3118,6 +3672,18 @@ function parseStv(data) {
   offset += 8;
   const minDeposit = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
   offset += 8;
+  const requestedBase = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const reservedBase = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const epochPps = new import_anchor3.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const nextEpochTs = data.readUInt32LE(offset);
+  offset += 4;
+  const epochSec = data.readUInt32LE(offset);
+  offset += 4;
+  const currentEpochId = data.readUInt32LE(offset);
+  offset += 4;
   const mgmtFeeBps = data.readUInt16LE(offset);
   offset += 2;
   const perfFeeBps = data.readUInt16LE(offset);
@@ -3127,7 +3693,6 @@ function parseStv(data) {
   const version = data.readUInt8(offset);
   offset += 1;
   const bump = data.readUInt8(offset);
-  offset += 1;
   return {
     baseMint,
     jlMint,
@@ -3139,6 +3704,12 @@ function parseStv(data) {
     accruedFeesJlx,
     maxDeposit,
     minDeposit,
+    requestedBase,
+    reservedBase,
+    epochPps,
+    nextEpochTs,
+    epochSec,
+    currentEpochId,
     mgmtFeeBps,
     perfFeeBps,
     flags,
@@ -3189,9 +3760,13 @@ var EXCHANGE_RATE_PRECISION_BI = BigInt(EXCHANGE_RATE_PRECISION);
 var RETURN_PERCENT_PRECISION = EXCHANGE_RATE_PRECISION_BI * 100n;
 var SECONDS_PER_YEAR = BigInt(365 * 24 * 60 * 60);
 var MAX_REWARDS_RATE = 50n * EXCHANGE_RATE_PRECISION_BI;
-function calculateNav(stvBaseBalance, stvJlxBalance, exchangeRate, baseLoaned) {
+function calculateNav(stvBaseBalance, stvJlxBalance, exchangeRate, baseLoaned, reservedBase) {
   const jlxValue = stvJlxBalance.mul(new import_anchor4.BN(exchangeRate.toString())).div(EXCHANGE_RATE_PRECISION_BN);
-  return stvBaseBalance.add(jlxValue).add(baseLoaned);
+  let nav = stvBaseBalance.add(jlxValue).add(baseLoaned);
+  if (reservedBase && !reservedBase.isZero()) {
+    nav = nav.sub(reservedBase);
+  }
+  return nav;
 }
 function calculatePps(nav, jvSupply) {
   if (jvSupply.isZero()) {
@@ -3638,7 +4213,8 @@ async function createInitializeStvInstruction(program, params, accounts) {
     mgmtFeeBps: params.mgmtFeeBps,
     perfFeeBps: params.perfFeeBps,
     maxDeposit: params.maxDeposit,
-    minDeposit: params.minDeposit
+    minDeposit: params.minDeposit,
+    epochSec: params.epochSec
   }).accounts({
     admin: accounts.admin,
     jlpVault: accounts.jlpVault,
@@ -3658,7 +4234,8 @@ async function createUpdateStvInstruction(program, params, accounts) {
     jlMint: params.jlMint,
     pps: params.pps,
     hwm: params.hwm,
-    baseLoaned: params.baseLoaned
+    baseLoaned: params.baseLoaned,
+    epochSec: params.epochSec
   }).accounts({
     admin: accounts.admin,
     jlpVault: accounts.jlpVault,
@@ -3682,20 +4259,32 @@ async function createDepositInstruction(program, amount, accounts, remainingAcco
     tokenProgram: accounts.tokenProgram
   }).remainingAccounts(remainingAccounts).instruction();
 }
-async function createWithdrawInstruction(program, sharesToBurn, accounts, remainingAccounts = []) {
-  return await program.methods.withdraw(sharesToBurn).accounts({
+async function createRequestWithdrawInstruction(program, params, accounts) {
+  return await program.methods.requestWithdraw(params.shares, params.epochId).accounts({
     user: accounts.user,
     jlpVault: accounts.jlpVault,
     stv: accounts.stv,
+    jvMint: accounts.jvMint,
+    userJvxAta: accounts.userJvxAta,
+    withdrawRequest: accounts.withdrawRequest,
+    requestJvxAta: accounts.requestJvxAta,
+    tokenProgram: accounts.tokenProgram,
+    associatedTokenProgram: accounts.associatedTokenProgram,
+    systemProgram: accounts.systemProgram
+  }).instruction();
+}
+async function createClaimWithdrawInstruction(program, accounts) {
+  return await program.methods.claimWithdraw().accounts({
+    user: accounts.user,
+    stv: accounts.stv,
     baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
     jvMint: accounts.jvMint,
     userBaseAta: accounts.userBaseAta,
-    userJvxAta: accounts.userJvxAta,
     stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
+    withdrawRequest: accounts.withdrawRequest,
+    requestJvxAta: accounts.requestJvxAta,
     tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
+  }).instruction();
 }
 
 // src/instructions/manager.ts
@@ -3737,24 +4326,6 @@ async function createMoveJlxInstruction(program, params, accounts, remainingAcco
     tokenProgram: accounts.tokenProgram
   }).remainingAccounts(remainingAccounts).instruction();
 }
-async function createSwapJlxJlxInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.swapJlxJlx({
-    fromIndex: params.fromIndex,
-    toIndex: params.toIndex,
-    amountIn: params.amountIn,
-    minOut: params.minOut,
-    jupiterData: params.jupiterData
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    fromJlxMint: accounts.fromJlxMint,
-    toJlxMint: accounts.toJlxMint,
-    fromJlxAta: accounts.fromJlxAta,
-    toJlxAta: accounts.toJlxAta,
-    tokenProgram: accounts.tokenProgram,
-    jupiterProgram: accounts.jupiterProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
 async function createSwapJlxJlpInstruction(program, params, accounts, remainingAccounts = []) {
   return await program.methods.swapJlxToFromJlp({
     stvIndex: params.stvIndex,
@@ -3772,10 +4343,21 @@ async function createSwapJlxJlpInstruction(program, params, accounts, remainingA
     jupiterProgram: accounts.jupiterProgram
   }).remainingAccounts(remainingAccounts).instruction();
 }
+async function createProcessEpochInstruction(program, accounts, remainingAccounts = []) {
+  return await program.methods.processEpoch().accounts({
+    payer: accounts.payer,
+    jlpVault: accounts.jlpVault,
+    stv: accounts.stv,
+    baseMint: accounts.baseMint,
+    jlMint: accounts.jlMint,
+    jvMint: accounts.jvMint,
+    stvBaseAta: accounts.stvBaseAta,
+    stvJlxAta: accounts.stvJlxAta,
+    tokenProgram: accounts.tokenProgram
+  }).remainingAccounts(remainingAccounts).instruction();
+}
 async function createSettleYieldInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.settleYield({
-    jlpRate: params.jlpRate
-  }).accounts({
+  return await program.methods.settleYield().accounts({
     jlpVault: accounts.jlpVault,
     vaultJlpAta: accounts.vaultJlpAta,
     stv0: accounts.stvBtc,
@@ -3791,7 +4373,8 @@ async function createSettleYieldInstruction(program, params, accounts, remaining
     dovesBtcUsd: accounts.oracleBtc,
     dovesEthUsd: accounts.oracleEth,
     dovesSolUsd: accounts.oracleSol,
-    pythJlpUsd: accounts.oracleJlp,
+    jlpPool: accounts.jlpPool,
+    jlpMintAccount: accounts.jlpMintAccount,
     manager: accounts.manager
   }).remainingAccounts(remainingAccounts).instruction();
 }
@@ -4062,8 +4645,8 @@ var PoolContext = class {
     }).compileToV0Message();
     return new import_web39.VersionedTransaction(message);
   }
-  // Burn jvX shares and withdraw base asset
-  async withdraw(params) {
+  // Request withdrawal: escrow jvX shares for the current epoch
+  async requestWithdraw(params) {
     if (params.shares.isZero() || params.shares.isNeg()) {
       throw new JlpdClientError("Withdraw shares must be positive");
     }
@@ -4072,28 +4655,66 @@ var PoolContext = class {
       this.client.connection.getLatestBlockhash("confirmed")
     ]);
     if (!stv) throw new JlpdClientError("STV not found");
+    const epochId = stv.currentEpochId;
+    const [withdrawRequestPda] = deriveWithdrawRequestPda(
+      this.stvPda,
+      params.user,
+      epochId,
+      this.client.programId
+    );
+    const requestJvxAta = (0, import_spl_token5.getAssociatedTokenAddressSync)(stv.jvMint, withdrawRequestPda, true);
     const userAtas = deriveUserAtas(this.pool.mint, stv.jvMint, params.user);
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createWithdrawInstruction(
+    const ix = await createRequestWithdrawInstruction(
       this.client.program,
-      params.shares,
+      { shares: params.shares, epochId },
       {
         user: params.user,
         jlpVault: this.client.vaultPda,
         stv: this.stvPda,
+        jvMint: stv.jvMint,
+        userJvxAta: userAtas.jvxAta,
+        withdrawRequest: withdrawRequestPda,
+        requestJvxAta,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
+        associatedTokenProgram: import_spl_token5.ASSOCIATED_TOKEN_PROGRAM_ID,
+        systemProgram: import_web39.SystemProgram.programId
+      }
+    );
+    const message = new import_web39.TransactionMessage({
+      payerKey: params.user,
+      recentBlockhash: blockhash,
+      instructions: [ix]
+    }).compileToV0Message();
+    return new import_web39.VersionedTransaction(message);
+  }
+  // Claim withdrawal: receive base tokens for a processed WithdrawRequest
+  async claimWithdraw(params) {
+    const [stv, { blockhash }] = await Promise.all([
+      this.client.fetchStv(this.pool.mint),
+      this.client.connection.getLatestBlockhash("confirmed")
+    ]);
+    if (!stv) throw new JlpdClientError("STV not found");
+    const [withdrawRequestPda] = deriveWithdrawRequestPda(
+      this.stvPda,
+      params.user,
+      params.epochId,
+      this.client.programId
+    );
+    const requestJvxAta = (0, import_spl_token5.getAssociatedTokenAddressSync)(stv.jvMint, withdrawRequestPda, true);
+    const userAtas = deriveUserAtas(this.pool.mint, stv.jvMint, params.user);
+    const ix = await createClaimWithdrawInstruction(
+      this.client.program,
+      {
+        user: params.user,
+        stv: this.stvPda,
         baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
         jvMint: stv.jvMint,
         userBaseAta: userAtas.baseAta,
-        userJvxAta: userAtas.jvxAta,
         stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta,
+        withdrawRequest: withdrawRequestPda,
+        requestJvxAta,
         tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
+      }
     );
     const message = new import_web39.TransactionMessage({
       payerKey: params.user,
@@ -4197,7 +4818,8 @@ var PoolContext = class {
         jlMint: params.jlMint ?? null,
         pps: params.pps ?? null,
         hwm: params.hwm ?? null,
-        baseLoaned: params.baseLoaned ?? null
+        baseLoaned: params.baseLoaned ?? null,
+        epochSec: params.epochSec ?? null
       },
       {
         admin: params.admin,
@@ -4284,83 +4906,6 @@ var SwapContext = class {
     }).compileToV0Message(params.quote.addressLookupTables);
     return new import_web39.VersionedTransaction(message);
   }
-  // Get a quote for jlX <-> jlX swap
-  async quoteJlxJlx(params) {
-    const fromPoolConfig = getPoolByName(params.fromPool);
-    const toPoolConfig = getPoolByName(params.toPool);
-    if (!fromPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.fromPool}`);
-    if (!toPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.toPool}`);
-    const inputMint = fromPoolConfig.fTokenMint;
-    const outputMint = toPoolConfig.fTokenMint;
-    const quote = await getJupiterQuote(
-      inputMint,
-      outputMint,
-      BigInt(params.amountIn.toString()),
-      params.slippageBps ?? 30,
-      40,
-      this.client.jupiterApiKey
-    );
-    const swapIxs = await getJupiterSwapInstructions(quote, this.client.vaultPda, this.client.jupiterApiKey);
-    const remainingAccounts = parseSwapRemainingAccounts(swapIxs.swapInstruction);
-    const alts = await fetchAddressLookupTables(
-      this.client.connection,
-      swapIxs.addressLookupTableAddresses
-    );
-    return {
-      inputMint,
-      outputMint,
-      inAmount: new import_anchor6.BN(quote.inAmount),
-      outAmount: new import_anchor6.BN(quote.outAmount),
-      minOutAmount: new import_anchor6.BN(quote.otherAmountThreshold),
-      priceImpactPct: parseFloat(quote.priceImpactPct),
-      route: quote.routePlan.map((r) => r.swapInfo.label || "unknown"),
-      jupiterData: Buffer.from(swapIxs.swapInstruction.data, "base64"),
-      remainingAccounts,
-      addressLookupTables: alts,
-      computeUnitLimit: swapIxs.computeUnitLimit ?? 6e5
-    };
-  }
-  // Build jlX <-> jlX swap transaction
-  async swapJlxJlx(params) {
-    const fromPoolConfig = getPoolByName(params.fromPool);
-    const toPoolConfig = getPoolByName(params.toPool);
-    if (!fromPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.fromPool}`);
-    if (!toPoolConfig) throw new JlpdClientError(`Unknown pool: ${params.toPool}`);
-    const fromPoolCtx = this.client.pool(params.fromPool);
-    const toPoolCtx = this.client.pool(params.toPool);
-    const computeIx = import_web39.ComputeBudgetProgram.setComputeUnitLimit({
-      units: params.quote.computeUnitLimit
-    });
-    const jupiterProgram = JUPITER_SWAP_PROGRAM_ID;
-    const swapIx = await createSwapJlxJlxInstruction(
-      this.client.program,
-      {
-        fromIndex: fromPoolConfig.stvIndex,
-        toIndex: toPoolConfig.stvIndex,
-        amountIn: params.amountIn,
-        minOut: params.minOut,
-        jupiterData: params.quote.jupiterData
-      },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        fromJlxMint: fromPoolConfig.fTokenMint,
-        toJlxMint: toPoolConfig.fTokenMint,
-        fromJlxAta: fromPoolCtx.vaultStagingAta,
-        toJlxAta: toPoolCtx.vaultStagingAta,
-        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID,
-        jupiterProgram
-      },
-      params.quote.remainingAccounts
-    );
-    const { blockhash } = await this.client.connection.getLatestBlockhash("confirmed");
-    const message = new import_web39.TransactionMessage({
-      payerKey: params.manager,
-      recentBlockhash: blockhash,
-      instructions: [computeIx, swapIx]
-    }).compileToV0Message(params.quote.addressLookupTables);
-    return new import_web39.VersionedTransaction(message);
-  }
 };
 var AdminContext = class {
   constructor(client) {
@@ -4398,7 +4943,8 @@ var AdminContext = class {
         mgmtFeeBps: params.mgmtFeeBps,
         perfFeeBps: params.perfFeeBps,
         maxDeposit: params.maxDeposit,
-        minDeposit: params.minDeposit
+        minDeposit: params.minDeposit,
+        epochSec: params.withdrawEpochSec
       },
       {
         admin: params.admin,
@@ -4411,6 +4957,46 @@ var AdminContext = class {
     );
     return this.client.buildTransaction(params.admin, [ix]);
   }
+  // Process epoch for a pool (manager operation)
+  async processEpoch(params) {
+    const pool = getPoolByName(params.poolName);
+    if (!pool) throw new JlpdClientError(`Unknown pool: ${params.poolName}`);
+    const [stvPda] = deriveStvPda(pool.mint, this.client.programId);
+    const stv = await this.client.fetchStv(pool.mint);
+    if (!stv) throw new JlpdClientError(`STV not found for pool: ${params.poolName}`);
+    const stvAtas = deriveStvAtas(pool.mint, pool.fTokenMint, stvPda);
+    const erAccounts = pool.hasJupiterLend ? buildExchangeRateAccounts(pool) : null;
+    const remainingAccounts = [];
+    if (erAccounts) {
+      remainingAccounts.push(
+        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
+        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
+      );
+    }
+    for (const wrPubkey of params.withdrawRequests) {
+      const requestJvxAta = (0, import_spl_token5.getAssociatedTokenAddressSync)(stv.jvMint, wrPubkey, true);
+      remainingAccounts.push(
+        { pubkey: wrPubkey, isSigner: false, isWritable: true },
+        { pubkey: requestJvxAta, isSigner: false, isWritable: true }
+      );
+    }
+    const ix = await createProcessEpochInstruction(
+      this.client.program,
+      {
+        payer: params.payer,
+        jlpVault: this.client.vaultPda,
+        stv: stvPda,
+        baseMint: pool.mint,
+        jlMint: pool.fTokenMint,
+        jvMint: stv.jvMint,
+        stvBaseAta: stvAtas.baseAta,
+        stvJlxAta: stvAtas.jlxAta,
+        tokenProgram: import_spl_token5.TOKEN_PROGRAM_ID
+      },
+      remainingAccounts
+    );
+    return this.client.buildTransaction(params.payer, [ix]);
+  }
   // Settle yield across all STVs
   async settleYield(params) {
     const poolNames = ["BTC", "ETH", "SOL", "USDC", "JupUSD"];
@@ -4441,7 +5027,7 @@ var AdminContext = class {
     const remainingAccounts = [...lendingAccounts, ...rewardsAccounts, ...mintAccounts];
     const ix = await createSettleYieldInstruction(
       this.client.program,
-      { jlpRate: params.jlpRate },
+      {},
       {
         manager: params.manager,
         jlpVault: this.client.vaultPda,
@@ -4460,13 +5046,58 @@ var AdminContext = class {
         oracleBtc: ORACLES.DOVES_BTC_USD,
         oracleEth: ORACLES.DOVES_ETH_USD,
         oracleSol: ORACLES.DOVES_SOL_USD,
-        oracleJlp: ORACLES.PYTH_JLP_USD
+        jlpPool: JLP_POOL_PUBKEY,
+        jlpMintAccount: MINTS.JLP
       },
       remainingAccounts
     );
     return this.client.buildTransaction(params.manager, [ix]);
   }
 };
+
+// src/accounts/withdraw_request.ts
+var import_web310 = require("@solana/web3.js");
+var import_anchor7 = require("@coral-xyz/anchor");
+var WITHDRAW_REQUEST_DATA_SIZE = 89;
+var WITHDRAW_REQUEST_ACCOUNT_SIZE = 8 + WITHDRAW_REQUEST_DATA_SIZE;
+var WITHDRAW_REQUEST_DISCRIMINATOR = Buffer.from([
+  186,
+  239,
+  174,
+  191,
+  189,
+  13,
+  47,
+  196
+]);
+function parseWithdrawRequest(data) {
+  if (data.length < WITHDRAW_REQUEST_ACCOUNT_SIZE) {
+    throw new Error(
+      `Invalid WithdrawRequest data size: expected ${WITHDRAW_REQUEST_ACCOUNT_SIZE}, got ${data.length}`
+    );
+  }
+  const discriminator = data.subarray(0, 8);
+  if (!discriminator.equals(WITHDRAW_REQUEST_DISCRIMINATOR)) {
+    throw new Error(
+      `Invalid WithdrawRequest discriminator: expected ${WITHDRAW_REQUEST_DISCRIMINATOR.toString("hex")}, got ${discriminator.toString("hex")}`
+    );
+  }
+  let offset = 8;
+  const stv = new import_web310.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const user = new import_web310.PublicKey(data.subarray(offset, offset + 32));
+  offset += 32;
+  const shares = new import_anchor7.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const pps = new import_anchor7.BN(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const epochId = data.readUInt32LE(offset);
+  offset += 4;
+  const claimAvailableAfter = data.readUInt32LE(offset);
+  offset += 4;
+  const bump = data.readUInt8(offset);
+  return { stv, user, shares, pps, epochId, claimAvailableAfter, bump };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdminContext,
@@ -4477,10 +5108,12 @@ var AdminContext = class {
   FLAG_REBALANCE_DISABLED,
   FLAG_WITHDRAWALS_DISABLED,
   JLPD_PROGRAM_ID,
+  JLP_POOL_PUBKEY,
   JLP_VAULT_ACCOUNT_SIZE,
   JLP_VAULT_DATA_SIZE,
   JLP_VAULT_DISCRIMINATOR,
   JUPITER_LEND_PROGRAM_ID,
+  JUPITER_PERPS_PROGRAM_ID,
   JUPITER_SWAP_PROGRAM_ID,
   JUPUSD_POOL,
   JUP_LEND_PROGRAM_ID,
@@ -4496,6 +5129,7 @@ var AdminContext = class {
   PoolContext,
   SEED_JLP_VAULT,
   SEED_STV,
+  SEED_WITHDRAW_REQUEST,
   STV_ACCOUNT_SIZE,
   STV_DATA_SIZE,
   STV_DISCRIMINATOR,
@@ -4504,6 +5138,9 @@ var AdminContext = class {
   USDC_POOL,
   WBTC_POOL,
   WETH_POOL,
+  WITHDRAW_REQUEST_ACCOUNT_SIZE,
+  WITHDRAW_REQUEST_DATA_SIZE,
+  WITHDRAW_REQUEST_DISCRIMINATOR,
   WSOL_POOL,
   baseToJlx,
   baseToShares,
@@ -4517,23 +5154,25 @@ var AdminContext = class {
   clearAtaCache,
   clearPdaCache,
   createClaimFeesInstruction,
+  createClaimWithdrawInstruction,
   createDepositInstruction,
   createInitOrUpdateVaultInstruction,
   createInitializeStvInstruction,
   createJupEarnInstruction,
   createMoveJlxInstruction,
+  createProcessEpochInstruction,
   createProgram,
+  createRequestWithdrawInstruction,
   createSettleYieldInstruction,
   createSwapJlxJlpInstruction,
-  createSwapJlxJlxInstruction,
   createUpdateStvInstruction,
-  createWithdrawInstruction,
   deriveAta,
   deriveStvAtas,
   deriveStvPda,
   deriveUserAtas,
   deriveVaultAtas,
   deriveVaultPda,
+  deriveWithdrawRequestPda,
   fetchAddressLookupTables,
   fetchJlpRate,
   fetchJupiterPriceUsd,
@@ -4547,5 +5186,6 @@ var AdminContext = class {
   parseStv,
   parseSwapRemainingAccounts,
   parseVault,
+  parseWithdrawRequest,
   sharesToBase
 });