@elmntl/jlpd-sdk 0.1.11 → 0.2.0

package/dist/index.mjs

@@ -3,11 +3,13 @@ import {
   PublicKey as PublicKey8,
   TransactionMessage,
   VersionedTransaction,
-  ComputeBudgetProgram
+  ComputeBudgetProgram,
+  SystemProgram as SystemProgram2
 } from "@solana/web3.js";
 import { BN as BN5 } from "@coral-xyz/anchor";
 import {
   TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2,
+  ASSOCIATED_TOKEN_PROGRAM_ID as ASSOCIATED_TOKEN_PROGRAM_ID2,
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2
 } from "@solana/spl-token";
 
@@ -108,66 +110,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 to close"
+            "STV's base ATA (source for base transfer)"
+          ],
+          writable: true
+        },
+        {
+          name: "withdraw_request",
+          docs: [
+            "WithdrawRequest PDA - closed after claim (rent to user)"
           ],
           writable: true,
           pda: {
@@ -175,33 +182,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",
-          docs: [
-            "jvX mint for this STV - used to verify no active shares"
-          ]
-        },
-        {
-          name: "base_mint",
+          name: "request_jvx_ata",
           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: []
@@ -463,7 +486,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
@@ -762,36 +785,335 @@ var jlp_d_program_default = {
           ]
         },
         {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA",
-            "For base-only pools, this is the base ATA (jl_mint == base_mint)"
-          ],
-          writable: true
+          name: "stv_jlx_ata",
+          docs: [
+            "STV's jlX ATA",
+            "For base-only pools, this is the base ATA (jl_mint == base_mint)"
+          ],
+          writable: true
+        },
+        {
+          name: "vault_staging_ata",
+          docs: [
+            "Vault's staging jlX ATA (for this specific jl_mint)",
+            "For base-only pools, this is the staging base ATA"
+          ],
+          writable: true
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Token program"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "params",
+          type: {
+            defined: {
+              name: "MoveJlxParams"
+            }
+          }
+        }
+      ]
+    },
+    {
+      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: "vault_staging_ata",
-          docs: [
-            "Vault's staging jlX ATA (for this specific jl_mint)",
-            "For base-only pools, this is the staging base ATA"
-          ],
-          writable: true
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
         },
         {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
+          name: "system_program",
+          address: "11111111111111111111111111111111"
         }
       ],
       args: [
         {
-          name: "params",
-          type: {
-            defined: {
-              name: "MoveJlxParams"
-            }
-          }
+          name: "shares",
+          type: "u64"
+        },
+        {
+          name: "epoch_id",
+          type: "u32"
         }
       ]
     },
@@ -1041,121 +1363,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: [
@@ -1184,6 +1391,19 @@ var jlp_d_program_default = {
         17,
         230
       ]
+    },
+    {
+      name: "WithdrawRequest",
+      discriminator: [
+        186,
+        239,
+        174,
+        191,
+        189,
+        13,
+        47,
+        196
+      ]
     }
   ],
   events: [
@@ -1200,6 +1420,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: [
@@ -1370,16 +1616,29 @@ var jlp_d_program_default = {
       ]
     },
     {
-      name: "Withdrawn",
+      name: "WithdrawClaimed",
       discriminator: [
-        20,
+        77,
+        130,
         89,
-        223,
-        198,
-        194,
-        124,
-        219,
-        13
+        38,
+        239,
+        172,
+        174,
+        85
+      ]
+    },
+    {
+      name: "WithdrawRequested",
+      discriminator: [
+        114,
+        16,
+        240,
+        206,
+        93,
+        128,
+        151,
+        39
       ]
     }
   ],
@@ -1610,14 +1869,132 @@ var jlp_d_program_default = {
       msg: "Test mode required: FLAG_TEST_MODE must be set for devnet/localnet builds"
     },
     {
-      code: 6045,
-      name: "NotAdmin",
-      msg: "Unauthorized: not admin"
-    }
-  ],
-  types: [
-    {
-      name: "Deposited",
+      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: [
+    {
+      name: "Deposited",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "stv",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "amount_base",
+            docs: [
+              "Amount of base asset deposited"
+            ],
+            type: "u64"
+          },
+          {
+            name: "shares_minted",
+            type: "u64"
+          },
+          {
+            name: "pps",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Direction",
+      docs: [
+        "Direction of jlX token movement between STV and Vault"
+      ],
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "ToVault"
+          },
+          {
+            name: "FromVault"
+          }
+        ]
+      }
+    },
+    {
+      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: [
@@ -1626,40 +2003,28 @@ var jlp_d_program_default = {
             type: "pubkey"
           },
           {
-            name: "user",
-            type: "pubkey"
+            name: "epoch_id",
+            type: "u32"
           },
           {
-            name: "amount_base",
-            docs: [
-              "Amount of base asset deposited"
-            ],
+            name: "pps",
             type: "u64"
           },
           {
-            name: "shares_minted",
+            name: "total_shares",
             type: "u64"
           },
           {
-            name: "pps",
+            name: "total_base",
             type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "Direction",
-      docs: [
-        "Direction of jlX token movement between STV and Vault"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
+          },
           {
-            name: "ToVault"
+            name: "new_epoch_id",
+            type: "u32"
           },
           {
-            name: "FromVault"
+            name: "new_next_epoch_ts",
+            type: "u32"
           }
         ]
       }
@@ -1849,6 +2214,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"
           }
         ]
       }
@@ -2294,7 +2666,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: {
@@ -2376,6 +2748,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: [
@@ -2410,6 +2826,18 @@ var jlp_d_program_default = {
               "PDA bump seed"
             ],
             type: "u8"
+          },
+          {
+            name: "_padding",
+            docs: [
+              "Alignment padding"
+            ],
+            type: {
+              array: [
+                "u8",
+                4
+              ]
+            }
           }
         ]
       }
@@ -2773,12 +3201,21 @@ var jlp_d_program_default = {
             type: {
               option: "u64"
             }
+          },
+          {
+            name: "epoch_sec",
+            docs: [
+              "Optional new epoch duration in seconds"
+            ],
+            type: {
+              option: "u32"
+            }
           }
         ]
       }
     },
     {
-      name: "Withdrawn",
+      name: "WithdrawClaimed",
       type: {
         kind: "struct",
         fields: [
@@ -2791,19 +3228,113 @@ var jlp_d_program_default = {
             type: "pubkey"
           },
           {
-            name: "shares_burned",
+            name: "shares",
             type: "u64"
           },
           {
-            name: "amount_base",
+            name: "base_amount",
+            type: "u64"
+          },
+          {
+            name: "epoch_id",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawRequest",
+      docs: [
+        "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: "stv",
+            docs: [
+              "Back-reference to the STV"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            docs: [
+              "The user who requested the withdrawal"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "shares",
             docs: [
-              "Amount of base asset withdrawn"
+              "Total jvX shares escrowed (accumulated across multiple requests in same epoch)"
             ],
             type: "u64"
           },
           {
             name: "pps",
+            docs: [
+              "PPS at process time (0 = unprocessed)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "epoch_id",
+            docs: [
+              "Epoch when request was made"
+            ],
+            type: "u32"
+          },
+          {
+            name: "claim_available_after",
+            docs: [
+              "Unix timestamp after which claim is available (0 = unprocessed)"
+            ],
+            type: "u32"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA bump seed"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawRequested",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "stv",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            type: "u64"
+          },
+          {
+            name: "total_shares",
             type: "u64"
+          },
+          {
+            name: "epoch_id",
+            type: "u32"
           }
         ]
       }
@@ -2838,6 +3369,7 @@ var JUPITER_SWAP_PROGRAM_ID = new 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;
@@ -2874,6 +3406,7 @@ var JUPITER_PERPS_PROGRAM_ID = new PublicKey("PERPHjGBqRHArX4DySjwM6UJHiR3sWAatq
 import { PublicKey as PublicKey2 } from "@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()}`;
@@ -2899,6 +3432,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 = PublicKey2.findProgramAddressSync(
+      [SEED_WITHDRAW_REQUEST_BUFFER, stvPda.toBuffer(), user.toBuffer(), epochIdBuffer],
+      programId
+    );
+    pdaCache.set(key, cached);
+  }
+  return cached;
+}
 function clearPdaCache() {
   pdaCache.clear();
 }
@@ -2977,7 +3524,7 @@ function parseVault(data) {
 // src/accounts/stv.ts
 import { PublicKey as PublicKey4 } from "@solana/web3.js";
 import { BN as BN2 } from "@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,
@@ -3022,6 +3569,18 @@ function parseStv(data) {
   offset += 8;
   const minDeposit = new BN2(data.subarray(offset, offset + 8), "le");
   offset += 8;
+  const requestedBase = new BN2(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const reservedBase = new BN2(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const epochPps = new BN2(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);
@@ -3031,7 +3590,6 @@ function parseStv(data) {
   const version = data.readUInt8(offset);
   offset += 1;
   const bump = data.readUInt8(offset);
-  offset += 1;
   return {
     baseMint,
     jlMint,
@@ -3043,6 +3601,12 @@ function parseStv(data) {
     accruedFeesJlx,
     maxDeposit,
     minDeposit,
+    requestedBase,
+    reservedBase,
+    epochPps,
+    nextEpochTs,
+    epochSec,
+    currentEpochId,
     mgmtFeeBps,
     perfFeeBps,
     flags,
@@ -3093,9 +3657,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 BN3(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()) {
@@ -3545,7 +4113,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,
@@ -3565,7 +4134,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,
@@ -3589,20 +4159,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
@@ -3661,6 +4243,19 @@ 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().accounts({
     jlpVault: accounts.jlpVault,
@@ -3950,8 +4545,8 @@ var PoolContext = class {
     }).compileToV0Message();
     return new 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");
     }
@@ -3960,28 +4555,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 = getAssociatedTokenAddressSync2(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: TOKEN_PROGRAM_ID2,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID2,
+        systemProgram: SystemProgram2.programId
+      }
+    );
+    const message = new TransactionMessage({
+      payerKey: params.user,
+      recentBlockhash: blockhash,
+      instructions: [ix]
+    }).compileToV0Message();
+    return new 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 = getAssociatedTokenAddressSync2(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: TOKEN_PROGRAM_ID2
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
+      }
     );
     const message = new TransactionMessage({
       payerKey: params.user,
@@ -4085,7 +4718,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,
@@ -4209,7 +4843,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,
@@ -4222,6 +4857,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 = getAssociatedTokenAddressSync2(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: TOKEN_PROGRAM_ID2
+      },
+      remainingAccounts
+    );
+    return this.client.buildTransaction(params.payer, [ix]);
+  }
   // Settle yield across all STVs
   async settleYield(params) {
     const poolNames = ["BTC", "ETH", "SOL", "USDC", "JupUSD"];
@@ -4279,6 +4954,50 @@ var AdminContext = class {
     return this.client.buildTransaction(params.manager, [ix]);
   }
 };
+
+// src/accounts/withdraw_request.ts
+import { PublicKey as PublicKey9 } from "@solana/web3.js";
+import { BN as BN6 } from "@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 PublicKey9(data.subarray(offset, offset + 32));
+  offset += 32;
+  const user = new PublicKey9(data.subarray(offset, offset + 32));
+  offset += 32;
+  const shares = new BN6(data.subarray(offset, offset + 8), "le");
+  offset += 8;
+  const pps = new BN6(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 };
+}
 export {
   AdminContext,
   EXCHANGE_RATE_PRECISION,
@@ -4309,6 +5028,7 @@ export {
   PoolContext,
   SEED_JLP_VAULT,
   SEED_STV,
+  SEED_WITHDRAW_REQUEST,
   STV_ACCOUNT_SIZE,
   STV_DATA_SIZE,
   STV_DISCRIMINATOR,
@@ -4317,6 +5037,9 @@ export {
   USDC_POOL,
   WBTC_POOL,
   WETH_POOL,
+  WITHDRAW_REQUEST_ACCOUNT_SIZE,
+  WITHDRAW_REQUEST_DATA_SIZE,
+  WITHDRAW_REQUEST_DISCRIMINATOR,
   WSOL_POOL,
   baseToJlx,
   baseToShares,
@@ -4330,22 +5053,25 @@ export {
   clearAtaCache,
   clearPdaCache,
   createClaimFeesInstruction,
+  createClaimWithdrawInstruction,
   createDepositInstruction,
   createInitOrUpdateVaultInstruction,
   createInitializeStvInstruction,
   createJupEarnInstruction,
   createMoveJlxInstruction,
+  createProcessEpochInstruction,
   createProgram,
+  createRequestWithdrawInstruction,
   createSettleYieldInstruction,
   createSwapJlxJlpInstruction,
   createUpdateStvInstruction,
-  createWithdrawInstruction,
   deriveAta,
   deriveStvAtas,
   deriveStvPda,
   deriveUserAtas,
   deriveVaultAtas,
   deriveVaultPda,
+  deriveWithdrawRequestPda,
   fetchAddressLookupTables,
   fetchJlpRate,
   fetchJupiterPriceUsd,
@@ -4359,5 +5085,6 @@ export {
   parseStv,
   parseSwapRemainingAccounts,
   parseVault,
+  parseWithdrawRequest,
   sharesToBase
 };