@elmntl/jlpd-sdk 0.2.0 → 0.13.4

package/dist/index.mjs

@@ -1,5090 +0,0 @@
-// src/client.ts
-import {
-  PublicKey as PublicKey8,
-  TransactionMessage,
-  VersionedTransaction,
-  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";
-
-// src/program.ts
-import { Program, AnchorProvider } from "@coral-xyz/anchor";
-import { Keypair } from "@solana/web3.js";
-
-// idl/jlp_d_program.json
-var jlp_d_program_default = {
-  address: "ELEM2bAobpZNuysfhyF28XGVjA1aTUwm6rPYyv1JX3oq",
-  metadata: {
-    name: "jlp_d_program",
-    version: "0.1.0",
-    spec: "0.1.0",
-    description: "Created with Anchor"
-  },
-  instructions: [
-    {
-      name: "claim_fees",
-      discriminator: [
-        82,
-        251,
-        233,
-        156,
-        12,
-        52,
-        184,
-        202
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager claiming fees on behalf of fee_receiver"
-          ],
-          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"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (Jupiter Lend token) - for decimals in transfer_checked"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "jvX mint (vault share token) - for supply reading in crystallization"
-          ]
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (for NAV calculation)"
-          ]
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (source for fee transfer)"
-          ],
-          writable: true
-        },
-        {
-          name: "fee_receiver_jlx_ata",
-          docs: [
-            "Fee receiver's jlX ATA (destination for fees)"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: []
-    },
-    {
-      name: "claim_withdraw",
-      docs: [
-        "Claim processed withdrawal (epoch-based delayed withdrawal)",
-        "",
-        "# 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: [
-        232,
-        89,
-        154,
-        117,
-        16,
-        204,
-        182,
-        224
-      ],
-      accounts: [
-        {
-          name: "user",
-          docs: [
-            "User claiming their withdrawal"
-          ],
-          writable: true,
-          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: "jv_mint",
-          docs: [
-            "jvX mint (for ATA close verification)"
-          ]
-        },
-        {
-          name: "user_base_ata",
-          docs: [
-            "User's base token destination"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "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: {
-            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: "account",
-                path: "withdraw_request.epoch_id",
-                account: "WithdrawRequest"
-              }
-            ]
-          }
-        },
-        {
-          name: "request_jvx_ata",
-          docs: [
-            "Empty jvX ATA owned by WithdrawRequest PDA (to close, rent to user)"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program"
-        }
-      ],
-      args: []
-    },
-    {
-      name: "deposit",
-      docs: [
-        "Deposit base asset into the STV and receive jvX shares",
-        "",
-        "# Flow",
-        "1. Crystallize fees inline (ensures fair PPS)",
-        "2. Transfer base asset from user to STV's base ATA",
-        "3. Mint jvX shares to user at post-fee PPS",
-        "",
-        "# Note",
-        "For pools with Jupiter Earn support (SOL, USDC), manager can later convert",
-        "base to jlX via jup_earn_deposit_withdraw instruction.",
-        "For pools without Jupiter Earn (BTC, ETH), base stays in STV's base ATA.",
-        "",
-        "Remaining accounts (optional, for exchange rate):",
-        "[0] = Jupiter Lend lending account",
-        "[1] = Jupiter Lend rewards rate model"
-      ],
-      discriminator: [
-        242,
-        35,
-        198,
-        137,
-        82,
-        225,
-        242,
-        182
-      ],
-      accounts: [
-        {
-          name: "user",
-          docs: [
-            "User performing the deposit"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: bump verified in handler after load() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: uses base_mint account for seeds; bump verified in handler"
-          ],
-          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 exchange rate reading"
-          ]
-        },
-        {
-          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 (source for deposit)"
-          ],
-          writable: true
-        },
-        {
-          name: "user_jvx_ata",
-          docs: [
-            "User's jvX token account (destination for shares)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "STV's base ATA (destination for user's base tokens)"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (used for NAV calculation)"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
-    },
-    {
-      name: "init_or_update_jlp_vault",
-      docs: [
-        "Initialize or update the global JLP Vault",
-        "Init: Creates vault PDA with admin, jlp_mint, base_asset_mints (immutable after init)",
-        "Update: Modifies manager, fee_receiver, and rebalance parameters",
-        "Note: ATAs are created externally via script"
-      ],
-      discriminator: [
-        234,
-        24,
-        218,
-        120,
-        213,
-        149,
-        245,
-        213
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin who controls the vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account (zero-copy)",
-            "Uses init_if_needed to support both init and update paths"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  106,
-                  108,
-                  112,
-                  95,
-                  118,
-                  97,
-                  117,
-                  108,
-                  116
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "system_program",
-          docs: [
-            "System program"
-          ],
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "InitOrUpdateJlpVaultParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "initialize_stv",
-      docs: [
-        "Initialize a Single Token Vault (STV) for a specific asset",
-        "Creates the STV PDA, jvX mint (with STV as authority), and jlX ATA"
-      ],
-      discriminator: [
-        136,
-        8,
-        178,
-        176,
-        57,
-        33,
-        1,
-        106
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin of the JLP Vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and admin verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account (zero-copy)"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  115,
-                  116,
-                  118
-                ]
-              },
-              {
-                kind: "account",
-                path: "base_mint"
-              }
-            ]
-          }
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (BTC, ETH, SOL, or USDC)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "Jupiter Lend token mint for this asset"
-          ]
-        },
-        {
-          name: "jv_mint",
-          docs: [
-            "Vault share token mint (jvX) - STV is the mint authority",
-            "Uses init_if_needed in case mint exists from a previous STV initialization"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "STV's jlX ATA (holds Jupiter Lend tokens)",
-            "Uses init_if_needed in case ATA exists from a previous STV initialization"
-          ],
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "account",
-                path: "stv"
-              },
-              {
-                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: "jl_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: "system_program",
-          docs: [
-            "System program"
-          ],
-          address: "11111111111111111111111111111111"
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        },
-        {
-          name: "associated_token_program",
-          docs: [
-            "Associated token program"
-          ],
-          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
-        },
-        {
-          name: "rent",
-          docs: [
-            "Rent sysvar"
-          ],
-          address: "SysvarRent111111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "InitializeStvParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "jup_earn_deposit_withdraw",
-      docs: [
-        "Deposit base to or withdraw from Jupiter Earn",
-        "",
-        "Manager-only operation to convert between base asset and jlX tokens",
-        "via Jupiter Lend. This is used for pools that support Jupiter Earn",
-        "(SOL, USDC) to earn yield on idle funds.",
-        "",
-        "# Directions",
-        "- Deposit: Convert base asset -> jlX (earn Jupiter Earn yield)",
-        "- Withdraw: Convert jlX -> base asset (provide withdrawal liquidity)",
-        "",
-        "# Use Cases",
-        "- After user deposits, manager can deposit base to Jupiter Earn",
-        "- Before user withdrawals, manager can withdraw from Jupiter Earn",
-        "- BTC/ETH pools cannot use Jupiter Earn (not supported)",
-        "",
-        "# Remaining Accounts",
-        "- Deposit: 17 Jupiter Lend accounts (see jup_lend::deposit_accounts)",
-        "- Withdraw: 18 Jupiter Lend accounts (see jup_lend::withdraw_accounts)"
-      ],
-      discriminator: [
-        124,
-        60,
-        71,
-        122,
-        162,
-        212,
-        164,
-        191
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the operation"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account",
-            "Note: PDA verified in handler"
-          ]
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_base_ata",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "stv_jlx_ata",
-          docs: [
-            "Using UncheckedAccount to avoid borrow conflicts with Jupiter Lend CPI"
-          ],
-          writable: true
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program - used to validate ATA ownership"
-          ],
-          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "JupEarnParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "move_stv_to_from_vault",
-      docs: [
-        "Move jlX tokens between STV and JLPVault staging ATA",
-        "Direction::ToVault: STV jlX ATA -> Vault staging ATA (preparation for swap)",
-        "Direction::FromVault: Vault staging ATA -> STV jlX ATA (return after swap/unwind)",
-        "",
-        "Remaining accounts (optional, for pools with Jupiter Earn):",
-        "[0] = Jupiter Lend lending account (for exchange rate)",
-        "[1] = Jupiter Lend rewards rate model (for exchange rate)",
-        "",
-        "For base-only pools (BTC, ETH where jl_mint == base_mint):",
-        "No remaining accounts needed - uses 1.0 exchange rate"
-      ],
-      discriminator: [
-        60,
-        104,
-        8,
-        126,
-        254,
-        244,
-        95,
-        221
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the operation"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account (mutable to update base_loaned)",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        },
-        {
-          name: "base_mint",
-          docs: [
-            "Base asset mint (for detection of base-only pools)"
-          ]
-        },
-        {
-          name: "jl_mint",
-          docs: [
-            "jlX mint (for decimals in transfer_checked)",
-            "For base-only pools (BTC, ETH), jl_mint == base_mint"
-          ]
-        },
-        {
-          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: "associated_token_program",
-          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "shares",
-          type: "u64"
-        },
-        {
-          name: "epoch_id",
-          type: "u32"
-        }
-      ]
-    },
-    {
-      name: "settle_yield",
-      docs: [
-        "Settle yield/loss from JLP positions across all STVs",
-        "Called periodically (~8 hours) to update all STV values based on JLP performance",
-        "",
-        "# USD-Based Settlement",
-        "1. Values total vault holdings (JLP + staging jlX) in USD using oracles",
-        "2. Values total base_loaned across all STVs in USD",
-        "3. Distributes surplus (yield) or deficit (bad debt) proportionally",
-        "",
-        "# Security",
-        "- BTC/ETH/SOL prices come from Doves oracles (manipulation-resistant)",
-        "- 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),",
-        "Jupiter Perps Pool account, JLP mint account",
-        "",
-        "# Remaining Accounts (15 accounts)",
-        "For exchange rate calculation with time-accrued rewards:",
-        "- [0-4]: Jupiter Lend lending accounts (BTC, ETH, SOL, USDC, JupUSD)",
-        "- [5-9]: Jupiter Lend rewards rate model accounts (BTC, ETH, SOL, USDC, JupUSD)",
-        "- [10-14]: jlX mint accounts (jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD)"
-      ],
-      discriminator: [
-        64,
-        28,
-        44,
-        24,
-        43,
-        204,
-        58,
-        215
-      ],
-      accounts: [
-        {
-          name: "jlp_vault",
-          writable: true
-        },
-        {
-          name: "vault_jlp_ata",
-          docs: [
-            "JLP token account owned by vault"
-          ]
-        },
-        {
-          name: "stv_0",
-          writable: true
-        },
-        {
-          name: "stv_1",
-          writable: true
-        },
-        {
-          name: "stv_2",
-          writable: true
-        },
-        {
-          name: "stv_3",
-          writable: true
-        },
-        {
-          name: "stv_4",
-          writable: true
-        },
-        {
-          name: "staging_jlx_0"
-        },
-        {
-          name: "staging_jlx_1"
-        },
-        {
-          name: "staging_jlx_2"
-        },
-        {
-          name: "staging_jlx_3"
-        },
-        {
-          name: "staging_jlx_4"
-        },
-        {
-          name: "doves_btc_usd"
-        },
-        {
-          name: "doves_eth_usd"
-        },
-        {
-          name: "doves_sol_usd"
-        },
-        {
-          name: "jlp_pool"
-        },
-        {
-          name: "jlp_mint_account"
-        },
-        {
-          name: "manager",
-          docs: [
-            "Manager who can perform rebalance operations (verified in handler)"
-          ],
-          signer: true
-        }
-      ],
-      args: []
-    },
-    {
-      name: "swap_jlx_to_from_jlp",
-      docs: [
-        "Swap between different jlX types (e.g., jlSOL -> jlUSDC) via Jupiter",
-        "Manager-only operation for rebalancing vault composition",
-        "",
-        "Remaining accounts: Jupiter swap accounts from API (varies based on route)",
-        "Swap between jlX and JLP tokens via Jupiter",
-        "JlxToJlp: Swap jlX -> JLP (increase vault JLP balance)",
-        "JlpToJlx: Swap JLP -> jlX (decrease vault JLP balance)",
-        "Manager-only operation for JLP position management",
-        "",
-        "Note: JLP positions are tracked via STV.base_loaned and settled",
-        "using settle_yield with Doves oracle prices (USD-based settlement).",
-        "",
-        "Remaining accounts: Jupiter swap accounts from API (varies based on route)"
-      ],
-      discriminator: [
-        229,
-        185,
-        136,
-        170,
-        210,
-        189,
-        172,
-        241
-      ],
-      accounts: [
-        {
-          name: "manager",
-          docs: [
-            "Manager performing the swap"
-          ],
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and manager verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "vault_jlx_ata",
-          docs: [
-            "Vault's staging jlX ATA (source for JlxToJlp, dest for JlpToJlx)",
-            "This is the jlX token that corresponds to stv_index"
-          ],
-          writable: true
-        },
-        {
-          name: "vault_jlp_ata",
-          docs: [
-            "Vault's JLP ATA (dest for JlxToJlp, source for JlpToJlx)"
-          ],
-          writable: true
-        },
-        {
-          name: "jlp_mint",
-          docs: [
-            "JLP mint"
-          ]
-        },
-        {
-          name: "token_program",
-          docs: [
-            "Token program"
-          ]
-        },
-        {
-          name: "jupiter_program",
-          docs: [
-            "Jupiter aggregator program"
-          ]
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "SwapJlxJlpParams"
-            }
-          }
-        }
-      ]
-    },
-    {
-      name: "update_stv",
-      docs: [
-        "Update STV parameters including fees and flags",
-        "Admin-only operation to modify STV configuration"
-      ],
-      discriminator: [
-        72,
-        173,
-        200,
-        203,
-        74,
-        83,
-        242,
-        43
-      ],
-      accounts: [
-        {
-          name: "admin",
-          docs: [
-            "Admin of the JLP Vault"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "jlp_vault",
-          docs: [
-            "The JLP Vault PDA account",
-            "Note: PDA and admin verified in handler via get_pda() to avoid multiple loads"
-          ]
-        },
-        {
-          name: "stv",
-          docs: [
-            "The STV PDA account to update",
-            "Note: PDA verified in handler via get_pda() to avoid multiple loads"
-          ],
-          writable: true
-        }
-      ],
-      args: [
-        {
-          name: "params",
-          type: {
-            defined: {
-              name: "UpdateStvParams"
-            }
-          }
-        }
-      ]
-    }
-  ],
-  accounts: [
-    {
-      name: "JLPVault",
-      discriminator: [
-        41,
-        108,
-        189,
-        168,
-        199,
-        152,
-        221,
-        119
-      ]
-    },
-    {
-      name: "STV",
-      discriminator: [
-        214,
-        2,
-        96,
-        41,
-        85,
-        163,
-        17,
-        230
-      ]
-    },
-    {
-      name: "WithdrawRequest",
-      discriminator: [
-        186,
-        239,
-        174,
-        191,
-        189,
-        13,
-        47,
-        196
-      ]
-    }
-  ],
-  events: [
-    {
-      name: "Deposited",
-      discriminator: [
-        111,
-        141,
-        26,
-        45,
-        161,
-        35,
-        100,
-        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: [
-        7,
-        214,
-        20,
-        27,
-        90,
-        132,
-        198,
-        77
-      ]
-    },
-    {
-      name: "FeesClaimed",
-      discriminator: [
-        22,
-        104,
-        110,
-        222,
-        38,
-        157,
-        14,
-        62
-      ]
-    },
-    {
-      name: "JlpSwapped",
-      discriminator: [
-        253,
-        47,
-        169,
-        18,
-        222,
-        203,
-        169,
-        15
-      ]
-    },
-    {
-      name: "JlpVaultInitialized",
-      discriminator: [
-        52,
-        94,
-        202,
-        211,
-        2,
-        98,
-        77,
-        229
-      ]
-    },
-    {
-      name: "JlpVaultUpdated",
-      discriminator: [
-        20,
-        204,
-        5,
-        243,
-        122,
-        9,
-        109,
-        130
-      ]
-    },
-    {
-      name: "JlxMoved",
-      discriminator: [
-        251,
-        80,
-        253,
-        180,
-        106,
-        69,
-        129,
-        70
-      ]
-    },
-    {
-      name: "JlxSwapped",
-      discriminator: [
-        200,
-        218,
-        196,
-        94,
-        186,
-        141,
-        86,
-        223
-      ]
-    },
-    {
-      name: "JupEarnEvent",
-      discriminator: [
-        138,
-        10,
-        64,
-        209,
-        244,
-        49,
-        1,
-        188
-      ]
-    },
-    {
-      name: "SettleYieldEvent",
-      discriminator: [
-        208,
-        142,
-        20,
-        32,
-        204,
-        216,
-        242,
-        189
-      ]
-    },
-    {
-      name: "SettleYieldSkipped",
-      discriminator: [
-        189,
-        221,
-        140,
-        115,
-        37,
-        102,
-        42,
-        195
-      ]
-    },
-    {
-      name: "SettleYieldStvEvent",
-      discriminator: [
-        12,
-        42,
-        226,
-        95,
-        60,
-        95,
-        192,
-        238
-      ]
-    },
-    {
-      name: "StvInitialized",
-      discriminator: [
-        41,
-        106,
-        196,
-        230,
-        138,
-        22,
-        195,
-        188
-      ]
-    },
-    {
-      name: "StvUpdated",
-      discriminator: [
-        108,
-        129,
-        139,
-        80,
-        212,
-        111,
-        83,
-        199
-      ]
-    },
-    {
-      name: "WithdrawClaimed",
-      discriminator: [
-        77,
-        130,
-        89,
-        38,
-        239,
-        172,
-        174,
-        85
-      ]
-    },
-    {
-      name: "WithdrawRequested",
-      discriminator: [
-        114,
-        16,
-        240,
-        206,
-        93,
-        128,
-        151,
-        39
-      ]
-    }
-  ],
-  errors: [
-    {
-      code: 6e3,
-      name: "Unauthorized",
-      msg: "Unauthorized: not admin"
-    },
-    {
-      code: 6001,
-      name: "NotManager",
-      msg: "Unauthorized: not manager"
-    },
-    {
-      code: 6002,
-      name: "VaultPaused",
-      msg: "Vault is paused"
-    },
-    {
-      code: 6003,
-      name: "DepositsDisabled",
-      msg: "Deposits disabled"
-    },
-    {
-      code: 6004,
-      name: "WithdrawalsDisabled",
-      msg: "Withdrawals disabled"
-    },
-    {
-      code: 6005,
-      name: "JlpDisabled",
-      msg: "JLP operations disabled"
-    },
-    {
-      code: 6006,
-      name: "RebalanceDisabled",
-      msg: "Rebalance operations disabled"
-    },
-    {
-      code: 6007,
-      name: "MathOverflow",
-      msg: "Math overflow"
-    },
-    {
-      code: 6008,
-      name: "InvalidTimestamp",
-      msg: "Invalid timestamp"
-    },
-    {
-      code: 6009,
-      name: "DivisionByZero",
-      msg: "Division by zero"
-    },
-    {
-      code: 6010,
-      name: "StagingNotZero",
-      msg: "Staging ATAs must be zero"
-    },
-    {
-      code: 6011,
-      name: "InsufficientLiquidity",
-      msg: "Insufficient liquidity for withdrawal"
-    },
-    {
-      code: 6012,
-      name: "InsufficientBalance",
-      msg: "Insufficient balance"
-    },
-    {
-      code: 6013,
-      name: "SlippageExceeded",
-      msg: "Slippage exceeded"
-    },
-    {
-      code: 6014,
-      name: "InvalidJlpVaultBump",
-      msg: "Invalid JLP vault PDA bump"
-    },
-    {
-      code: 6015,
-      name: "InvalidStvBump",
-      msg: "Invalid STV PDA bump"
-    },
-    {
-      code: 6016,
-      name: "InvalidJlMint",
-      msg: "Invalid jlX mint (Jupiter Lend token)"
-    },
-    {
-      code: 6017,
-      name: "InvalidJvMint",
-      msg: "Invalid jvX mint (vault share token)"
-    },
-    {
-      code: 6018,
-      name: "InvalidBaseMint",
-      msg: "Invalid base asset mint"
-    },
-    {
-      code: 6019,
-      name: "InvalidJlpMint",
-      msg: "Invalid JLP mint"
-    },
-    {
-      code: 6020,
-      name: "InvalidOwner",
-      msg: "Invalid account owner"
-    },
-    {
-      code: 6021,
-      name: "InvalidStvIndex",
-      msg: "Invalid STV index"
-    },
-    {
-      code: 6022,
-      name: "InvalidFeeParams",
-      msg: "Invalid fee parameters"
-    },
-    {
-      code: 6023,
-      name: "AmountTooSmall",
-      msg: "Amount too small"
-    },
-    {
-      code: 6024,
-      name: "ZeroAmount",
-      msg: "Zero amount not allowed"
-    },
-    {
-      code: 6025,
-      name: "FeeCapExceeded",
-      msg: "Fee cap exceeded"
-    },
-    {
-      code: 6026,
-      name: "MintMismatch",
-      msg: "Mint mismatch"
-    },
-    {
-      code: 6027,
-      name: "InsufficientAccounts",
-      msg: "Insufficient accounts provided"
-    },
-    {
-      code: 6028,
-      name: "InvalidProgram",
-      msg: "Invalid program ID"
-    },
-    {
-      code: 6029,
-      name: "InvalidSwapDiscriminator",
-      msg: "Invalid swap discriminator"
-    },
-    {
-      code: 6030,
-      name: "MaxDepositExceeded",
-      msg: "Deposit exceeds maximum allowed"
-    },
-    {
-      code: 6031,
-      name: "InvalidLendingAccount",
-      msg: "Invalid Jupiter Lend lending account"
-    },
-    {
-      code: 6032,
-      name: "MissingExchangeRateAccounts",
-      msg: "Missing exchange rate accounts - lending and rewards_rate_model required for pools with Jupiter Earn"
-    },
-    {
-      code: 6033,
-      name: "JupiterLendCpiFailed",
-      msg: "Jupiter Lend CPI failed"
-    },
-    {
-      code: 6034,
-      name: "JupiterSwapCpiFailed",
-      msg: "Jupiter swap CPI failed"
-    },
-    {
-      code: 6035,
-      name: "OracleStale",
-      msg: "Oracle price is stale - older than staleness threshold"
-    },
-    {
-      code: 6036,
-      name: "OraclePriceNegative",
-      msg: "Oracle returned negative price"
-    },
-    {
-      code: 6037,
-      name: "InvalidBaseAssetIndex",
-      msg: "Invalid base asset index"
-    },
-    {
-      code: 6038,
-      name: "PriceFeedMismatch",
-      msg: "Price feed mismatch"
-    },
-    {
-      code: 6039,
-      name: "OracleAccountInvalid",
-      msg: "Oracle account invalid"
-    },
-    {
-      code: 6040,
-      name: "InvalidAccountData",
-      msg: "Invalid account data - could not parse account"
-    },
-    {
-      code: 6041,
-      name: "InvalidExchangeRate",
-      msg: "Invalid exchange rate from Jupiter Lend"
-    },
-    {
-      code: 6042,
-      name: "InvalidOracleAccount",
-      msg: "Invalid oracle account - not owned by expected program"
-    },
-    {
-      code: 6043,
-      name: "JlpPriceOutOfRange",
-      msg: "JLP price out of reasonable range ($0.50 - $50.00)"
-    },
-    {
-      code: 6044,
-      name: "TestModeRequired",
-      msg: "Test mode required: FLAG_TEST_MODE must be set for devnet/localnet builds"
-    },
-    {
-      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: [
-          {
-            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: [
-        "Event emitted when claim_fees returns early (no fees to claim)"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "reason",
-            docs: [
-              'Reason for skipping: "NoFeesToClaim"'
-            ],
-            type: "string"
-          }
-        ]
-      }
-    },
-    {
-      name: "FeesClaimed",
-      docs: [
-        "Fee claim event - when manager claims accrued fees"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "amount_jlx",
-            docs: [
-              "Total jlX claimed by fee receiver"
-            ],
-            type: "u64"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Fee receiver who received the fees"
-            ],
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "InitOrUpdateJlpVaultParams",
-      docs: [
-        "Parameters for initializing or updating the JLP Vault"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "jlp_mint",
-            docs: [
-              "JLP token mint - required for init, ignored on update"
-            ],
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "base_asset_mints",
-            docs: [
-              "Base asset token mints [BTC, ETH, SOL, USDC, JupUSD] - required for init, ignored on update"
-            ],
-            type: {
-              option: {
-                array: [
-                  "pubkey",
-                  5
-                ]
-              }
-            }
-          },
-          {
-            name: "jlx_asset_mints",
-            docs: [
-              "jlX token mints [jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD] - required for init, ignored on update"
-            ],
-            type: {
-              option: {
-                array: [
-                  "pubkey",
-                  5
-                ]
-              }
-            }
-          },
-          {
-            name: "new_admin",
-            docs: [
-              "New admin address - if Some, transfers admin ownership (only current admin can do this)"
-            ],
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "manager",
-            docs: [
-              "Manager address (can perform rebalance operations)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Fee receiver address"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "flags",
-            docs: [
-              "Vault flags (paused, deposits disabled, etc.)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "jlp_slippage_bps",
-            docs: [
-              "JLP swap slippage tolerance in basis points (e.g., 100 = 1%)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "oracle_staleness_threshold",
-            docs: [
-              "Maximum age in seconds for Doves oracle prices to be considered valid.",
-              "On init: defaults to 60 seconds if None.",
-              "On update: if None, keeps existing value; if Some, updates to new value."
-            ],
-            type: {
-              option: "u64"
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "InitializeStvParams",
-      docs: [
-        "Parameters for initializing 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: "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: "epoch_sec",
-            docs: [
-              "Epoch duration in seconds for delayed withdrawals"
-            ],
-            type: "u32"
-          }
-        ]
-      }
-    },
-    {
-      name: "JLPVault",
-      docs: [
-        "JLPVault - Global vault configuration account",
-        'Seeds: ["jlp_vault"]',
-        "Size: 8 (discriminator) + 464 (data) = 472 bytes",
-        "",
-        "## USD-Based Settlement Model",
-        "This vault uses USD-based settlement where JLP positions are tracked via",
-        "each STV's `base_loaned` field. Yield is settled by marking `base_loaned`",
-        "to market using Doves oracle prices."
-      ],
-      serialization: "bytemuck",
-      repr: {
-        kind: "c"
-      },
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "admin",
-            docs: [
-              "Admin who can update vault configuration"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "manager",
-            docs: [
-              "Manager who can perform rebalance operations"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            docs: [
-              "Account that receives fees"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jlp_mint",
-            docs: [
-              "JLP token mint address"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "base_asset_mints",
-            docs: [
-              "Base asset token mints [BTC, ETH, SOL, USDC, JupUSD]"
-            ],
-            type: {
-              array: [
-                "pubkey",
-                5
-              ]
-            }
-          },
-          {
-            name: "jlx_asset_mints",
-            docs: [
-              "jlX token mints [jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD]"
-            ],
-            type: {
-              array: [
-                "pubkey",
-                5
-              ]
-            }
-          },
-          {
-            name: "oracle_staleness_threshold",
-            docs: [
-              "Maximum age in seconds for Doves oracle prices to be considered valid.",
-              "Used during yield settlement to ensure price freshness.",
-              "Default: 60 seconds. Setting to 0 disables staleness check (not recommended)."
-            ],
-            type: "u64"
-          },
-          {
-            name: "flags",
-            docs: [
-              "Vault state flags"
-            ],
-            type: "u16"
-          },
-          {
-            name: "jlp_slippage_bps",
-            docs: [
-              "JLP swap slippage tolerance in basis points (e.g., 100 = 1%)"
-            ],
-            type: "u16"
-          },
-          {
-            name: "version",
-            docs: [
-              "Account version for migrations"
-            ],
-            type: "u8"
-          },
-          {
-            name: "bump",
-            docs: [
-              "PDA bump seed"
-            ],
-            type: "u8"
-          },
-          {
-            name: "reserved",
-            docs: [
-              "Reserved for 8-byte alignment"
-            ],
-            type: {
-              array: [
-                "u8",
-                2
-              ]
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpSwapped",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "stv_index",
-            type: "u8"
-          },
-          {
-            name: "amount_in",
-            type: "u64"
-          },
-          {
-            name: "amount_out",
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = JlxToJlp, 1 = JlpToJlx"
-            ],
-            type: "u8"
-          },
-          {
-            name: "jlp_balance_before",
-            type: "u64"
-          },
-          {
-            name: "jlp_balance_after",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpVaultInitialized",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "admin",
-            type: "pubkey"
-          },
-          {
-            name: "manager",
-            type: "pubkey"
-          },
-          {
-            name: "fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "jlp_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlpVaultUpdated",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "old_manager",
-            type: "pubkey"
-          },
-          {
-            name: "new_manager",
-            type: "pubkey"
-          },
-          {
-            name: "old_fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "new_fee_receiver",
-            type: "pubkey"
-          },
-          {
-            name: "old_flags",
-            type: "u16"
-          },
-          {
-            name: "new_flags",
-            type: "u16"
-          },
-          {
-            name: "old_jlp_slippage_bps",
-            type: "u16"
-          },
-          {
-            name: "new_jlp_slippage_bps",
-            type: "u16"
-          },
-          {
-            name: "old_oracle_staleness_threshold",
-            type: "u64"
-          },
-          {
-            name: "new_oracle_staleness_threshold",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlxMoved",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "amount_jlx",
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = ToVault (STV -> Vault), 1 = FromVault (Vault -> STV)"
-            ],
-            type: "u8"
-          },
-          {
-            name: "base_value",
-            docs: [
-              "Base asset value of the jlX moved (at current exchange rate)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "exchange_rate",
-            docs: [
-              "Jupiter Lend exchange rate used for calculation (12 decimals)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "new_base_loaned",
-            docs: [
-              "New base_loaned after the move"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JlxSwapped",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            type: "pubkey"
-          },
-          {
-            name: "from_index",
-            type: "u8"
-          },
-          {
-            name: "to_index",
-            type: "u8"
-          },
-          {
-            name: "amount_in",
-            type: "u64"
-          },
-          {
-            name: "min_out",
-            type: "u64"
-          },
-          {
-            name: "amount_out",
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnDirection",
-      docs: [
-        "Direction for Jupiter Earn operations"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "Deposit"
-          },
-          {
-            name: "Withdraw"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnEvent",
-      docs: [
-        "Event emitted for Jupiter Earn deposit/withdraw operations"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction: 0 = Deposit (base -> jlX), 1 = Withdraw (jlX -> base)"
-            ],
-            type: "u8"
-          },
-          {
-            name: "base_amount",
-            docs: [
-              "Amount of base asset (deposited or received)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "jlx_amount",
-            docs: [
-              "Amount of jlX (received or burned)"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "JupEarnParams",
-      docs: [
-        "Parameters for Jupiter Earn deposit/withdraw"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "direction",
-            docs: [
-              "Direction of the operation"
-            ],
-            type: {
-              defined: {
-                name: "JupEarnDirection"
-              }
-            }
-          },
-          {
-            name: "amount",
-            docs: [
-              "Amount to deposit (base) or withdraw (jlX)"
-            ],
-            type: "u64"
-          }
-        ]
-      }
-    },
-    {
-      name: "MoveJlxParams",
-      docs: [
-        "Parameters for moving jlX tokens between STV and Vault"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "amount_jlx",
-            docs: [
-              "Amount of jlX tokens to move"
-            ],
-            type: "u64"
-          },
-          {
-            name: "direction",
-            docs: [
-              "Direction of the transfer"
-            ],
-            type: {
-              defined: {
-                name: "Direction"
-              }
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "STV",
-      docs: [
-        "STV - Single Token Vault account",
-        'Seeds: ["stv", base_mint.key().as_ref()]',
-        "Size: 8 (discriminator) + 200 (data) = 208 bytes"
-      ],
-      serialization: "bytemuck",
-      repr: {
-        kind: "c"
-      },
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "base_mint",
-            docs: [
-              "Base asset mint (BTC, ETH, SOL, or USDC)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jl_mint",
-            docs: [
-              "Jupiter Lend token mint (jlBTC, jlETH, jlSOL, jlUSDC, jlJupUSD)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "jv_mint",
-            docs: [
-              "Vault share token mint (jvBTC, jvETH, jvSOL, jvUSDC, jvJupUSD)"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "pps",
-            docs: [
-              "Price per share in base asset terms (scaled by PPS_DECIMALS)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "hwm",
-            docs: [
-              "High water mark for performance fee (scaled by PPS_DECIMALS)"
-            ],
-            type: "u64"
-          },
-          {
-            name: "last_mgmt_fee_ts",
-            docs: [
-              "Timestamp of last management fee accrual"
-            ],
-            type: "u64"
-          },
-          {
-            name: "base_loaned",
-            docs: [
-              "Base asset value loaned to JLP Vault (illiquid assets)",
-              "Updated on: move_stv_to_from_vault (+/-), settle_yield (+/-)",
-              "Denominated in base asset (SOL, BTC, etc.), NOT jlX"
-            ],
-            type: "u64"
-          },
-          {
-            name: "accrued_fees_jlx",
-            docs: [
-              "Accrued fees in jlX terms (unclaimed, reduces effective NAV for PPS)",
-              "Updated on: crystallize_fees (+), claim_fees (reset to 0)"
-            ],
-            type: "u64"
-          },
-          {
-            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: "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: [
-              "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: "version",
-            docs: [
-              "Account version for migrations"
-            ],
-            type: "u8"
-          },
-          {
-            name: "bump",
-            docs: [
-              "PDA bump seed"
-            ],
-            type: "u8"
-          },
-          {
-            name: "_padding",
-            docs: [
-              "Alignment padding"
-            ],
-            type: {
-              array: [
-                "u8",
-                4
-              ]
-            }
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldEvent",
-      docs: [
-        "Aggregate yield settlement event - emitted once per settle_yield call"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            docs: [
-              "The JLP vault"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "vault_usd",
-            docs: [
-              "Total vault USD value (JLP + staging jlX) with 6 decimals"
-            ],
-            type: "u128"
-          },
-          {
-            name: "total_loaned_usd",
-            docs: [
-              "Total base_loaned USD value across all STVs with 6 decimals"
-            ],
-            type: "u128"
-          },
-          {
-            name: "delta_usd",
-            docs: [
-              "Absolute delta between vault_usd and total_loaned_usd"
-            ],
-            type: "u128"
-          },
-          {
-            name: "is_surplus",
-            docs: [
-              "True if vault_usd >= total_loaned_usd (yield), false if deficit (bad debt)"
-            ],
-            type: "bool"
-          },
-          {
-            name: "timestamp",
-            docs: [
-              "Settlement timestamp"
-            ],
-            type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldSkipped",
-      docs: [
-        "Event emitted when settle_yield returns early (no loans outstanding)"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "vault",
-            docs: [
-              "The JLP vault"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "reason",
-            docs: [
-              'Reason for skipping: "NoLoansOutstanding"'
-            ],
-            type: "string"
-          }
-        ]
-      }
-    },
-    {
-      name: "SettleYieldStvEvent",
-      docs: [
-        "Per-STV yield settlement event - emitted for each STV with non-zero base_loaned"
-      ],
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            docs: [
-              "The STV account"
-            ],
-            type: "pubkey"
-          },
-          {
-            name: "old_base_loaned",
-            docs: [
-              "base_loaned before settlement"
-            ],
-            type: "u64"
-          },
-          {
-            name: "new_base_loaned",
-            docs: [
-              "base_loaned after settlement"
-            ],
-            type: "u64"
-          },
-          {
-            name: "adjustment_base",
-            docs: [
-              "Adjustment amount in base asset terms"
-            ],
-            type: "u64"
-          },
-          {
-            name: "is_surplus",
-            docs: [
-              "True if surplus (yield added), false if deficit (bad debt deducted)"
-            ],
-            type: "bool"
-          }
-        ]
-      }
-    },
-    {
-      name: "StvInitialized",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "base_mint",
-            type: "pubkey"
-          },
-          {
-            name: "jl_mint",
-            type: "pubkey"
-          },
-          {
-            name: "jv_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "StvUpdated",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "base_mint",
-            type: "pubkey"
-          },
-          {
-            name: "old_mgmt_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "new_mgmt_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "old_perf_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "new_perf_fee_bps",
-            type: "u16"
-          },
-          {
-            name: "old_flags",
-            type: "u16"
-          },
-          {
-            name: "new_flags",
-            type: "u16"
-          },
-          {
-            name: "old_max_deposit",
-            type: "u64"
-          },
-          {
-            name: "new_max_deposit",
-            type: "u64"
-          },
-          {
-            name: "old_min_deposit",
-            type: "u64"
-          },
-          {
-            name: "new_min_deposit",
-            type: "u64"
-          },
-          {
-            name: "old_jl_mint",
-            type: "pubkey"
-          },
-          {
-            name: "new_jl_mint",
-            type: "pubkey"
-          }
-        ]
-      }
-    },
-    {
-      name: "SwapDirection",
-      docs: [
-        "Direction of the swap operation"
-      ],
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "JlxToJlp"
-          },
-          {
-            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: "WithdrawClaimed",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "stv",
-            type: "pubkey"
-          },
-          {
-            name: "user",
-            type: "pubkey"
-          },
-          {
-            name: "shares",
-            type: "u64"
-          },
-          {
-            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: [
-              "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"
-          }
-        ]
-      }
-    }
-  ]
-};
-
-// src/program.ts
-var DUMMY_WALLET = {
-  publicKey: Keypair.generate().publicKey,
-  signTransaction: async (tx) => tx,
-  signAllTransactions: async (txs) => txs
-};
-function createProgram(connection) {
-  const provider = new AnchorProvider(connection, DUMMY_WALLET, {
-    commitment: "confirmed"
-  });
-  return new Program(jlp_d_program_default, provider);
-}
-
-// src/constants.ts
-import { PublicKey } from "@solana/web3.js";
-import { NATIVE_MINT } from "@solana/spl-token";
-var JLPD_PROGRAM_ID = new PublicKey(
-  "ELEM2bAobpZNuysfhyF28XGVjA1aTUwm6rPYyv1JX3oq"
-);
-var JUPITER_LEND_PROGRAM_ID = new PublicKey(
-  "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"
-);
-var JUPITER_SWAP_PROGRAM_ID = new PublicKey(
-  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
-);
-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;
-var FLAG_JLP_DISABLED = 8;
-var FLAG_REBALANCE_DISABLED = 16;
-var PPS_DECIMALS = 1e9;
-var EXCHANGE_RATE_PRECISION = 1e12;
-var MINTS = {
-  JLP: new PublicKey("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4"),
-  WSOL: NATIVE_MINT,
-  USDC: new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
-  WBTC: new PublicKey("3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"),
-  WETH: new PublicKey("7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"),
-  JupUSD: new PublicKey("JuprjznTrTSp2UFa3ZBUFgwdAmtZCq4MQCwysN55USD")
-};
-var STV_INDEX = /* @__PURE__ */ ((STV_INDEX2) => {
-  STV_INDEX2[STV_INDEX2["BTC"] = 0] = "BTC";
-  STV_INDEX2[STV_INDEX2["ETH"] = 1] = "ETH";
-  STV_INDEX2[STV_INDEX2["SOL"] = 2] = "SOL";
-  STV_INDEX2[STV_INDEX2["USDC"] = 3] = "USDC";
-  STV_INDEX2[STV_INDEX2["JupUSD"] = 4] = "JupUSD";
-  return STV_INDEX2;
-})(STV_INDEX || {});
-var ORACLES = {
-  // Doves oracles (Jupiter Perps oracle system)
-  DOVES_BTC_USD: new PublicKey("4HBbPx9QJdjJ7GUe6bsiJjGybvfpDhQMMPXP1UEa7VT5"),
-  DOVES_ETH_USD: new PublicKey("5URYohbPy32nxK1t3jAHVNfdWY2xTubHiFvLrE3VhXEp"),
-  DOVES_SOL_USD: new PublicKey("39cWjvHrpHNz2SbXv6ME4NPhqBDBd4KsjUYv5JkHEAJU")
-};
-var JLP_POOL_PUBKEY = new PublicKey("5BUwFW4nRbftYTDMbgxykoFWqWHPzahFSNAaaaJtVKsq");
-var JUPITER_PERPS_PROGRAM_ID = new PublicKey("PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu");
-
-// src/accounts/pdas.ts
-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()}`;
-  let cached = pdaCache.get(key);
-  if (!cached) {
-    cached = PublicKey2.findProgramAddressSync(
-      [SEED_JLP_VAULT_BUFFER],
-      programId
-    );
-    pdaCache.set(key, cached);
-  }
-  return cached;
-}
-function deriveStvPda(baseMint, programId) {
-  const key = `stv:${baseMint.toBase58()}:${programId.toBase58()}`;
-  let cached = pdaCache.get(key);
-  if (!cached) {
-    cached = PublicKey2.findProgramAddressSync(
-      [SEED_STV_BUFFER, baseMint.toBuffer()],
-      programId
-    );
-    pdaCache.set(key, cached);
-  }
-  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();
-}
-
-// src/accounts/vault.ts
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
-var JLP_VAULT_DATA_SIZE = 464;
-var JLP_VAULT_ACCOUNT_SIZE = 8 + JLP_VAULT_DATA_SIZE;
-var JLP_VAULT_DISCRIMINATOR = Buffer.from([
-  41,
-  108,
-  189,
-  168,
-  199,
-  152,
-  221,
-  119
-]);
-function parseVault(data) {
-  if (data.length < JLP_VAULT_ACCOUNT_SIZE) {
-    throw new Error(
-      `Invalid JLPVault data size: expected ${JLP_VAULT_ACCOUNT_SIZE}, got ${data.length}`
-    );
-  }
-  const discriminator = data.subarray(0, 8);
-  if (!discriminator.equals(JLP_VAULT_DISCRIMINATOR)) {
-    throw new Error(
-      `Invalid JLPVault discriminator: expected ${JLP_VAULT_DISCRIMINATOR.toString("hex")}, got ${discriminator.toString("hex")}`
-    );
-  }
-  let offset = 8;
-  const admin = new PublicKey3(data.subarray(offset, offset + 32));
-  offset += 32;
-  const manager = new PublicKey3(data.subarray(offset, offset + 32));
-  offset += 32;
-  const feeReceiver = new PublicKey3(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jlpMint = new PublicKey3(data.subarray(offset, offset + 32));
-  offset += 32;
-  const baseAssetMints = [];
-  for (let i = 0; i < 5; i++) {
-    baseAssetMints.push(new PublicKey3(data.subarray(offset, offset + 32)));
-    offset += 32;
-  }
-  const jlxAssetMints = [];
-  for (let i = 0; i < 5; i++) {
-    jlxAssetMints.push(new PublicKey3(data.subarray(offset, offset + 32)));
-    offset += 32;
-  }
-  const oracleStalenessThreshold = new BN(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const flags = data.readUInt16LE(offset);
-  offset += 2;
-  const jlpSlippageBps = data.readUInt16LE(offset);
-  offset += 2;
-  const version = data.readUInt8(offset);
-  offset += 1;
-  const bump = data.readUInt8(offset);
-  offset += 1;
-  return {
-    admin,
-    manager,
-    feeReceiver,
-    jlpMint,
-    baseAssetMints,
-    jlxAssetMints,
-    oracleStalenessThreshold,
-    flags,
-    jlpSlippageBps,
-    version,
-    bump
-  };
-}
-
-// src/accounts/stv.ts
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
-import { BN as BN2 } from "@coral-xyz/anchor";
-var STV_DATA_SIZE = 200;
-var STV_ACCOUNT_SIZE = 8 + STV_DATA_SIZE;
-var STV_DISCRIMINATOR = Buffer.from([
-  214,
-  2,
-  96,
-  41,
-  85,
-  163,
-  17,
-  230
-]);
-function parseStv(data) {
-  if (data.length < STV_ACCOUNT_SIZE) {
-    throw new Error(
-      `Invalid STV data size: expected ${STV_ACCOUNT_SIZE}, got ${data.length}`
-    );
-  }
-  const discriminator = data.subarray(0, 8);
-  if (!discriminator.equals(STV_DISCRIMINATOR)) {
-    throw new Error(
-      `Invalid STV discriminator: expected ${STV_DISCRIMINATOR.toString("hex")}, got ${discriminator.toString("hex")}`
-    );
-  }
-  let offset = 8;
-  const baseMint = new PublicKey4(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jlMint = new PublicKey4(data.subarray(offset, offset + 32));
-  offset += 32;
-  const jvMint = new PublicKey4(data.subarray(offset, offset + 32));
-  offset += 32;
-  const pps = new BN2(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const hwm = new BN2(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const lastMgmtFeeTs = new BN2(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const baseLoaned = new BN2(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const accruedFeesJlx = new BN2(data.subarray(offset, offset + 8), "le");
-  offset += 8;
-  const maxDeposit = new BN2(data.subarray(offset, offset + 8), "le");
-  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);
-  offset += 2;
-  const flags = data.readUInt16LE(offset);
-  offset += 2;
-  const version = data.readUInt8(offset);
-  offset += 1;
-  const bump = data.readUInt8(offset);
-  return {
-    baseMint,
-    jlMint,
-    jvMint,
-    pps,
-    hwm,
-    lastMgmtFeeTs,
-    baseLoaned,
-    accruedFeesJlx,
-    maxDeposit,
-    minDeposit,
-    requestedBase,
-    reservedBase,
-    epochPps,
-    nextEpochTs,
-    epochSec,
-    currentEpochId,
-    mgmtFeeBps,
-    perfFeeBps,
-    flags,
-    version,
-    bump
-  };
-}
-
-// src/utils/ata.ts
-import { getAssociatedTokenAddressSync } from "@solana/spl-token";
-var ataCache = /* @__PURE__ */ new Map();
-function deriveAta(mint, owner, allowPda = false) {
-  const key = `${mint.toBase58()}:${owner.toBase58()}:${allowPda}`;
-  let cached = ataCache.get(key);
-  if (!cached) {
-    cached = getAssociatedTokenAddressSync(mint, owner, allowPda);
-    ataCache.set(key, cached);
-  }
-  return cached;
-}
-function deriveUserAtas(baseMint, jvMint, userWallet) {
-  return {
-    baseAta: deriveAta(baseMint, userWallet, false),
-    jvxAta: deriveAta(jvMint, userWallet, false)
-  };
-}
-function deriveStvAtas(baseMint, jlxMint, stvPda) {
-  return {
-    baseAta: deriveAta(baseMint, stvPda, true),
-    jlxAta: deriveAta(jlxMint, stvPda, true)
-  };
-}
-function deriveVaultAtas(jlxMint, jlpMint, vaultPda) {
-  return {
-    stagingAta: deriveAta(jlxMint, vaultPda, true),
-    jlpAta: deriveAta(jlpMint, vaultPda, true)
-  };
-}
-function clearAtaCache() {
-  ataCache.clear();
-}
-
-// src/utils/math.ts
-import { BN as BN3 } from "@coral-xyz/anchor";
-var PPS_DECIMALS_BN = new BN3(PPS_DECIMALS);
-var EXCHANGE_RATE_PRECISION_BN = new BN3(EXCHANGE_RATE_PRECISION);
-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, reservedBase) {
-  const jlxValue = stvJlxBalance.mul(new BN3(exchangeRate.toString())).div(EXCHANGE_RATE_PRECISION_BN);
-  let nav = stvBaseBalance.add(jlxValue).add(baseLoaned);
-  if (reservedBase && !reservedBase.isZero()) {
-    nav = nav.sub(reservedBase);
-  }
-  return nav;
-}
-function calculatePps(nav, jvSupply) {
-  if (jvSupply.isZero()) {
-    return new BN3(PPS_DECIMALS);
-  }
-  return nav.mul(PPS_DECIMALS_BN).div(jvSupply);
-}
-function sharesToBase(shares, pps) {
-  if (pps.isZero()) {
-    throw new Error("Price per share cannot be zero");
-  }
-  return shares.mul(pps).div(PPS_DECIMALS_BN);
-}
-function baseToShares(base, pps) {
-  if (pps.isZero()) {
-    throw new Error("Price per share cannot be zero");
-  }
-  return base.mul(PPS_DECIMALS_BN).div(pps);
-}
-function jlxToBase(jlxAmount, exchangeRate) {
-  if (exchangeRate.isZero()) {
-    throw new Error("Exchange rate cannot be zero");
-  }
-  return jlxAmount.mul(exchangeRate).div(EXCHANGE_RATE_PRECISION_BN);
-}
-function baseToJlx(baseAmount, exchangeRate) {
-  if (exchangeRate.isZero()) {
-    throw new Error("Exchange rate cannot be zero");
-  }
-  return baseAmount.mul(EXCHANGE_RATE_PRECISION_BN).div(exchangeRate);
-}
-function calculateExchangeRate(storedRate, rewardsRate, currentTimestamp, lastUpdateTimestamp, fTokenTotalSupply) {
-  if (fTokenTotalSupply === 0n) {
-    return storedRate;
-  }
-  const totalAssets = storedRate * fTokenTotalSupply / EXCHANGE_RATE_PRECISION_BI;
-  if (totalAssets === 0n || rewardsRate === 0n) {
-    return storedRate;
-  }
-  const timeDiff = currentTimestamp - lastUpdateTimestamp;
-  if (timeDiff <= 0n) {
-    return storedRate;
-  }
-  const rate = rewardsRate * RETURN_PERCENT_PRECISION / totalAssets;
-  const cappedRate = rate > MAX_REWARDS_RATE ? MAX_REWARDS_RATE : rate;
-  const priceIncrease = storedRate * cappedRate * timeDiff / RETURN_PERCENT_PRECISION / SECONDS_PER_YEAR;
-  return storedRate + priceIncrease;
-}
-
-// src/jupiter/pools.ts
-import { PublicKey as PublicKey5 } from "@solana/web3.js";
-import { NATIVE_MINT as NATIVE_MINT2 } from "@solana/spl-token";
-var LENDING_ADMIN = new PublicKey5("5nmGjA4s7ATzpBQXC5RNceRpaJ7pYw2wKsNBWyuSAZV6");
-var LIQUIDITY_PROGRAM_ID = new PublicKey5("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC");
-var LIQUIDITY_SINGLETON = new PublicKey5("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z");
-var WSOL_POOL = {
-  mint: NATIVE_MINT2,
-  name: "SOL",
-  lending: new PublicKey5("BeAqbxfrcXmzEYT2Ra62oW2MqkuFDHaCtps47Mzg6Zj3"),
-  fTokenMint: new PublicKey5("2uQsyo1fXXQkDtcpXnLofWy88PxcvnfH2L8FPSE62FVU"),
-  tokenReservesLiquidity: new PublicKey5("4Y66HtUEqbbbpZdENGtFdVhUMS3tnagffn3M4do59Nfy"),
-  supplyPositionOnLiquidity: new PublicKey5("4SkEYxmiRgQ4VYyvh9VB4k39M49BpqazyzDUFDzJhXQm"),
-  rewardsRateModel: new PublicKey5("CkeQGDRsgMZcCaU8cZEdC2aFAohia4jLzL36RaLcUDsR"),
-  vault: new PublicKey5("5JP5zgYCb9W37QQLgAHRHuinFLrKt87akDY1CgZoTPzr"),
-  rateModel: new PublicKey5("Acvyi9HBGmqh3Exe1N4PjBVyY8fokq2AdC6fSLqV6KSo"),
-  claimAccount: new PublicKey5("6AQGR8zK4KTVZfZ9UZaRzyEL5ynvwVaF5ywVdmtJT24N"),
-  decimals: 9,
-  stvIndex: 2 /* SOL */,
-  hasJupiterLend: true,
-  jupDirectSwap: false
-};
-var USDC_POOL = {
-  mint: MINTS.USDC,
-  name: "USDC",
-  lending: new PublicKey5("2vVYHYM8VYnvZqQWpTJSj8o8DBf1wM8pVs3bsTgYZiqJ"),
-  fTokenMint: new PublicKey5("9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D"),
-  tokenReservesLiquidity: new PublicKey5("94vK29npVbyRHXH63rRcTiSr26SFhrQTzbpNJuhQEDu"),
-  supplyPositionOnLiquidity: new PublicKey5("Hf9gtkM4dpVBahVSzEXSVCAPpKzBsBcns3s8As3z77oF"),
-  rewardsRateModel: new PublicKey5("5xSPBiD3TibamAnwHDhZABdB4z4F9dcj5PnbteroBTTd"),
-  vault: new PublicKey5("BmkUoKMFYBxNSzWXyUjyMJjMAaVz4d8ZnxwwmhDCUXFB"),
-  rateModel: new PublicKey5("5pjzT5dFTsXcwixoab1QDLvZQvpYJxJeBphkyfHGn688"),
-  claimAccount: new PublicKey5("HN1r4VfkDn53xQQfeGDYrNuDKFdemAhZsHYRwBrFhsW"),
-  decimals: 6,
-  stvIndex: 3 /* USDC */,
-  hasJupiterLend: true,
-  jupDirectSwap: true
-};
-var JUPUSD_POOL = {
-  mint: MINTS.JupUSD,
-  name: "JupUSD",
-  lending: new PublicKey5("papYEgeG5uPE4niUWZhihUUzVVotJn1mAWbYo2UBSHi"),
-  fTokenMint: new PublicKey5("7GxATsNMnaC88vdwd2t3mwrFuQwwGvmYPrUQ4D6FotXk"),
-  tokenReservesLiquidity: new PublicKey5("2tQE8jVR5ezDw3PDa21BNzfyQ14Ug5cTf6n3swJNjkod"),
-  supplyPositionOnLiquidity: new PublicKey5("DXFoJruECdEch2KpzLQ2cSpxoBSsyg4bpYPnHYofsbD4"),
-  rewardsRateModel: new PublicKey5("E3U32h49TL9Qof3NeLja9qJxTrGYpY1o1NQPtrSLJjcc"),
-  vault: new PublicKey5("9kGqd5zsQGaFfFPdUuEgbRM4V7x72Jdt7WTS4uRouAQ7"),
-  rateModel: new PublicKey5("2hT44GA9r5PiqsbbmqN5CuF7ymtquoEdokRncAs9CVej"),
-  claimAccount: new PublicKey5("6q9vTzAsTMEPUCwuhEdJSJdpRNXnubwKZbi2go1B8nvg"),
-  decimals: 6,
-  stvIndex: 4 /* JupUSD */,
-  hasJupiterLend: true,
-  jupDirectSwap: true
-};
-var WBTC_POOL = {
-  mint: MINTS.WBTC,
-  name: "BTC",
-  lending: PublicKey5.default,
-  fTokenMint: MINTS.WBTC,
-  // jlBTC = WBTC (base-only)
-  tokenReservesLiquidity: PublicKey5.default,
-  supplyPositionOnLiquidity: PublicKey5.default,
-  rewardsRateModel: PublicKey5.default,
-  vault: PublicKey5.default,
-  rateModel: PublicKey5.default,
-  claimAccount: PublicKey5.default,
-  decimals: 8,
-  stvIndex: 0 /* BTC */,
-  hasJupiterLend: false,
-  jupDirectSwap: true
-};
-var WETH_POOL = {
-  mint: MINTS.WETH,
-  name: "ETH",
-  lending: PublicKey5.default,
-  fTokenMint: MINTS.WETH,
-  // jlETH = WETH (base-only)
-  tokenReservesLiquidity: PublicKey5.default,
-  supplyPositionOnLiquidity: PublicKey5.default,
-  rewardsRateModel: PublicKey5.default,
-  vault: PublicKey5.default,
-  rateModel: PublicKey5.default,
-  claimAccount: PublicKey5.default,
-  decimals: 8,
-  stvIndex: 1 /* ETH */,
-  hasJupiterLend: false,
-  jupDirectSwap: true
-};
-var POOLS = {
-  SOL: WSOL_POOL,
-  USDC: USDC_POOL,
-  JupUSD: JUPUSD_POOL,
-  BTC: WBTC_POOL,
-  ETH: WETH_POOL
-};
-var POOLS_BY_MINT = new Map(
-  Object.values(POOLS).map((p) => [p.mint.toBase58(), p])
-);
-function getPoolByName(name) {
-  return POOLS[name];
-}
-function getPoolByMint(mint) {
-  return POOLS_BY_MINT.get(mint.toBase58());
-}
-
-// src/jupiter/lend.ts
-import { PublicKey as PublicKey6, SystemProgram } from "@solana/web3.js";
-import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
-var JUPITER_LEND_PROGRAM_ID2 = new PublicKey6(
-  "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"
-);
-function buildExchangeRateAccounts(pool) {
-  if (!pool.hasJupiterLend) {
-    return null;
-  }
-  return {
-    lending: pool.lending,
-    rewardsRateModel: pool.rewardsRateModel
-  };
-}
-function buildJupEarnDepositAccounts(pool, stvPda, stvBaseAta, stvJlxAta) {
-  if (!pool.hasJupiterLend) {
-    throw new Error(`Pool ${pool.name} does not support Jupiter Lend`);
-  }
-  return [
-    { pubkey: stvPda, isSigner: false, isWritable: true },
-    { pubkey: stvBaseAta, isSigner: false, isWritable: true },
-    { pubkey: stvJlxAta, isSigner: false, isWritable: true },
-    { pubkey: pool.mint, isSigner: false, isWritable: false },
-    { pubkey: LENDING_ADMIN, isSigner: false, isWritable: false },
-    { pubkey: pool.lending, isSigner: false, isWritable: true },
-    { pubkey: pool.fTokenMint, isSigner: false, isWritable: true },
-    { pubkey: pool.tokenReservesLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.supplyPositionOnLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.rateModel, isSigner: false, isWritable: false },
-    { pubkey: pool.vault, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_SINGLETON, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_PROGRAM_ID, isSigner: false, isWritable: true },
-    { pubkey: pool.rewardsRateModel, isSigner: false, isWritable: false },
-    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-    { pubkey: JUPITER_LEND_PROGRAM_ID2, isSigner: false, isWritable: false }
-  ];
-}
-function buildJupEarnWithdrawAccounts(pool, stvPda, stvJlxAta, stvBaseAta) {
-  if (!pool.hasJupiterLend) {
-    throw new Error(`Pool ${pool.name} does not support Jupiter Lend`);
-  }
-  return [
-    { pubkey: stvPda, isSigner: false, isWritable: true },
-    { pubkey: stvJlxAta, isSigner: false, isWritable: true },
-    { pubkey: stvBaseAta, isSigner: false, isWritable: true },
-    { pubkey: LENDING_ADMIN, isSigner: false, isWritable: false },
-    { pubkey: pool.lending, isSigner: false, isWritable: true },
-    { pubkey: pool.mint, isSigner: false, isWritable: false },
-    { pubkey: pool.fTokenMint, isSigner: false, isWritable: true },
-    { pubkey: pool.tokenReservesLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.supplyPositionOnLiquidity, isSigner: false, isWritable: true },
-    { pubkey: pool.rateModel, isSigner: false, isWritable: false },
-    { pubkey: pool.vault, isSigner: false, isWritable: true },
-    { pubkey: pool.claimAccount, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_SINGLETON, isSigner: false, isWritable: true },
-    { pubkey: LIQUIDITY_PROGRAM_ID, isSigner: false, isWritable: true },
-    { pubkey: pool.rewardsRateModel, isSigner: false, isWritable: false },
-    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-    { pubkey: JUPITER_LEND_PROGRAM_ID2, isSigner: false, isWritable: false }
-  ];
-}
-function parseLendingAccount(data) {
-  return {
-    mint: new PublicKey6(data.slice(8, 40)),
-    fTokenMint: new PublicKey6(data.slice(40, 72)),
-    lendingId: data.readUInt16LE(72),
-    decimals: data[74],
-    rewardsRateModel: new PublicKey6(data.slice(75, 107)),
-    liquidityExchangePrice: data.readBigUInt64LE(107),
-    tokenExchangePrice: data.readBigUInt64LE(115),
-    lastUpdateTimestamp: data.readBigUInt64LE(123),
-    tokenReservesLiquidity: new PublicKey6(data.slice(131, 163)),
-    supplyPositionOnLiquidity: new PublicKey6(data.slice(163, 195)),
-    bump: data[195]
-  };
-}
-function parseRewardsRateModel(data) {
-  return {
-    mint: new PublicKey6(data.slice(8, 40)),
-    startTvl: data.readBigUInt64LE(40),
-    duration: data.readBigUInt64LE(48),
-    startTime: data.readBigUInt64LE(56),
-    yearlyReward: data.readBigUInt64LE(64),
-    nextDuration: data.readBigUInt64LE(72),
-    nextRewardAmount: data.readBigUInt64LE(80),
-    bump: data[88]
-  };
-}
-
-// src/jupiter/swap.ts
-import {
-  PublicKey as PublicKey7,
-  AddressLookupTableAccount
-} from "@solana/web3.js";
-var JUPITER_API_BASE = "https://api.jup.ag/swap/v1";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var MAX_RETRIES = 3;
-var RETRY_DELAY_MS = 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function fetchWithRetry(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS, retries = MAX_RETRIES) {
-  let lastError = null;
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        return response;
-      }
-      if (response.status >= 400 && response.status < 500) {
-        const errorText = await response.text();
-        throw new Error(`Jupiter API error (${response.status}): ${errorText}`);
-      }
-      lastError = new Error(`Jupiter API returned ${response.status}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          lastError = new Error(`Request timed out after ${timeoutMs}ms`);
-        } else {
-          lastError = error;
-        }
-      }
-    }
-    if (attempt < retries - 1) {
-      await sleep(RETRY_DELAY_MS * (attempt + 1));
-    }
-  }
-  throw lastError ?? new Error("Unknown error during fetch");
-}
-async function getJupiterQuote(inputMint, outputMint, amount, slippageBps = 50, maxAccounts = 40, apiKey) {
-  const params = new URLSearchParams({
-    inputMint: inputMint.toBase58(),
-    outputMint: outputMint.toBase58(),
-    amount: amount.toString(),
-    slippageBps: slippageBps.toString(),
-    maxAccounts: maxAccounts.toString()
-  });
-  const url = `${JUPITER_API_BASE}/quote?${params.toString()}`;
-  const headers = {};
-  if (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  const response = await fetchWithRetry(url, { headers });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Jupiter quote error: ${data.error}`);
-  }
-  return data;
-}
-async function getJupiterSwapInstructions(quote, userPubkey, apiKey) {
-  const url = `${JUPITER_API_BASE}/swap-instructions`;
-  const body = {
-    quoteResponse: quote,
-    userPublicKey: userPubkey.toBase58(),
-    wrapAndUnwrapSol: false,
-    dynamicComputeUnitLimit: true,
-    skipUserAccountsRpcCalls: true
-  };
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  const response = await fetchWithRetry(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Jupiter swap instructions error: ${data.error}`);
-  }
-  return data;
-}
-function parseSwapRemainingAccounts(swapInstruction) {
-  return swapInstruction.accounts.map((acc) => ({
-    pubkey: new PublicKey7(acc.pubkey),
-    isSigner: false,
-    // Always false for CPI — vault PDA signs via seeds
-    isWritable: acc.isWritable
-  }));
-}
-async function fetchAddressLookupTables(connection, addresses) {
-  if (addresses.length === 0) {
-    return [];
-  }
-  const pubkeys = addresses.map((addr) => new PublicKey7(addr));
-  const accountInfos = await connection.getMultipleAccountsInfo(pubkeys);
-  const tables = [];
-  for (let i = 0; i < accountInfos.length; i++) {
-    const info = accountInfos[i];
-    if (info === null) {
-      console.warn(`ALT not found: ${addresses[i]}`);
-      continue;
-    }
-    const table = new AddressLookupTableAccount({
-      key: pubkeys[i],
-      state: AddressLookupTableAccount.deserialize(info.data)
-    });
-    tables.push(table);
-  }
-  return tables;
-}
-async function buildSwapData(connection, inputMint, outputMint, amount, userPubkey, slippageBps = 50, maxAccounts = 40, apiKey) {
-  const quote = await getJupiterQuote(
-    inputMint,
-    outputMint,
-    amount,
-    slippageBps,
-    maxAccounts,
-    apiKey
-  );
-  const instructions = await getJupiterSwapInstructions(quote, userPubkey, apiKey);
-  const remainingAccounts = parseSwapRemainingAccounts(instructions.swapInstruction);
-  const addressLookupTables = await fetchAddressLookupTables(
-    connection,
-    instructions.addressLookupTableAddresses
-  );
-  return {
-    quote,
-    instructions,
-    remainingAccounts,
-    addressLookupTables
-  };
-}
-
-// src/jupiter/price.ts
-import { BN as BN4 } from "@coral-xyz/anchor";
-async function fetchJupiterPriceUsd(mint, apiKey) {
-  const url = `https://api.jup.ag/price/v3?ids=${mint}`;
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "x-api-key": apiKey
-      }
-    });
-    if (!response.ok) {
-      console.warn(`Jupiter Price API error: ${response.status}`);
-      return null;
-    }
-    const data = await response.json();
-    const priceData = data[mint];
-    if (!priceData?.usdPrice) {
-      console.warn(`No price data for ${mint}`);
-      return null;
-    }
-    return priceData.usdPrice;
-  } catch (error) {
-    console.warn(`Failed to fetch Jupiter price: ${error.message}`);
-    return null;
-  }
-}
-async function fetchJlpRate(jlpMint, fallbackPrice = 4.6, apiKey) {
-  const priceUsd = await fetchJupiterPriceUsd(jlpMint, apiKey);
-  if (priceUsd === null) {
-    console.warn(`Using fallback JLP price: $${fallbackPrice}`);
-    return new BN4(Math.round(fallbackPrice * 1e8));
-  }
-  console.log(`JLP price: $${priceUsd.toFixed(4)} -> ${Math.round(priceUsd * 1e8)} (8 decimals)`);
-  return new BN4(Math.round(priceUsd * 1e8));
-}
-
-// src/instructions/admin.ts
-async function createInitOrUpdateVaultInstruction(program, params, accounts) {
-  return await program.methods.initOrUpdateJlpVault({
-    jlpMint: params.jlpMint,
-    baseAssetMints: params.baseAssetMints,
-    jlxAssetMints: params.jlxAssetMints,
-    newAdmin: params.newAdmin,
-    manager: params.manager,
-    feeReceiver: params.feeReceiver,
-    flags: params.flags,
-    jlpSlippageBps: params.jlpSlippageBps,
-    oracleStalenessThreshold: params.oracleStalenessThreshold
-  }).accounts({
-    admin: accounts.admin
-  }).instruction();
-}
-async function createInitializeStvInstruction(program, params, accounts) {
-  return await program.methods.initializeStv({
-    mgmtFeeBps: params.mgmtFeeBps,
-    perfFeeBps: params.perfFeeBps,
-    maxDeposit: params.maxDeposit,
-    minDeposit: params.minDeposit,
-    epochSec: params.epochSec
-  }).accounts({
-    admin: accounts.admin,
-    jlpVault: accounts.jlpVault,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    tokenProgram: accounts.tokenProgram
-  }).instruction();
-}
-async function createUpdateStvInstruction(program, params, accounts) {
-  return await program.methods.updateStv({
-    mgmtFeeBps: params.mgmtFeeBps,
-    perfFeeBps: params.perfFeeBps,
-    flags: params.flags,
-    maxDeposit: params.maxDeposit,
-    minDeposit: params.minDeposit,
-    jlMint: params.jlMint,
-    pps: params.pps,
-    hwm: params.hwm,
-    baseLoaned: params.baseLoaned,
-    epochSec: params.epochSec
-  }).accounts({
-    admin: accounts.admin,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv
-  }).instruction();
-}
-
-// src/instructions/user.ts
-async function createDepositInstruction(program, amount, accounts, remainingAccounts = []) {
-  return await program.methods.deposit(amount).accounts({
-    user: accounts.user,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    userBaseAta: accounts.userBaseAta,
-    userJvxAta: accounts.userJvxAta,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-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,
-    jvMint: accounts.jvMint,
-    userBaseAta: accounts.userBaseAta,
-    stvBaseAta: accounts.stvBaseAta,
-    withdrawRequest: accounts.withdrawRequest,
-    requestJvxAta: accounts.requestJvxAta,
-    tokenProgram: accounts.tokenProgram
-  }).instruction();
-}
-
-// src/instructions/manager.ts
-function toAnchorJupEarnDirection(dir) {
-  return dir === "Deposit" ? { deposit: {} } : { withdraw: {} };
-}
-function toAnchorMoveDirection(dir) {
-  return dir === "ToVault" ? { toVault: {} } : { fromVault: {} };
-}
-function toAnchorSwapDirection(dir) {
-  return dir === "JlxToJlp" ? { jlxToJlp: {} } : { jlpToJlx: {} };
-}
-async function createJupEarnInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.jupEarnDepositWithdraw({
-    direction: toAnchorJupEarnDirection(params.direction),
-    amount: params.amount
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createMoveJlxInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.moveStvToFromVault({
-    amountJlx: params.amountJlx,
-    direction: toAnchorMoveDirection(params.direction)
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    stvJlxAta: accounts.stvJlxAta,
-    vaultStagingAta: accounts.vaultStagingAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-async function createSwapJlxJlpInstruction(program, params, accounts, remainingAccounts = []) {
-  return await program.methods.swapJlxToFromJlp({
-    stvIndex: params.stvIndex,
-    direction: toAnchorSwapDirection(params.direction),
-    amountIn: params.amountIn,
-    expectedAmountOut: params.expectedAmountOut,
-    jupiterData: params.jupiterData
-  }).accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    vaultJlxAta: accounts.vaultJlxAta,
-    vaultJlpAta: accounts.vaultJlpAta,
-    jlpMint: accounts.jlpMint,
-    tokenProgram: accounts.tokenProgram,
-    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,
-    vaultJlpAta: accounts.vaultJlpAta,
-    stv0: accounts.stvBtc,
-    stv1: accounts.stvEth,
-    stv2: accounts.stvSol,
-    stv3: accounts.stvUsdc,
-    stv4: accounts.stvJupusd,
-    stagingJlx0: accounts.stagingBtc,
-    stagingJlx1: accounts.stagingEth,
-    stagingJlx2: accounts.stagingSol,
-    stagingJlx3: accounts.stagingUsdc,
-    stagingJlx4: accounts.stagingJupusd,
-    dovesBtcUsd: accounts.oracleBtc,
-    dovesEthUsd: accounts.oracleEth,
-    dovesSolUsd: accounts.oracleSol,
-    jlpPool: accounts.jlpPool,
-    jlpMintAccount: accounts.jlpMintAccount,
-    manager: accounts.manager
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-
-// src/instructions/fees.ts
-async function createClaimFeesInstruction(program, accounts, remainingAccounts = []) {
-  return await program.methods.claimFees().accounts({
-    manager: accounts.manager,
-    jlpVault: accounts.jlpVault,
-    stv: accounts.stv,
-    baseMint: accounts.baseMint,
-    jlMint: accounts.jlMint,
-    jvMint: accounts.jvMint,
-    stvBaseAta: accounts.stvBaseAta,
-    stvJlxAta: accounts.stvJlxAta,
-    feeReceiverJlxAta: accounts.feeReceiverJlxAta,
-    tokenProgram: accounts.tokenProgram
-  }).remainingAccounts(remainingAccounts).instruction();
-}
-
-// src/client.ts
-var JlpdClientError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "JlpdClientError";
-  }
-};
-var JlpdClient = class _JlpdClient {
-  constructor(connection, programId = JLPD_PROGRAM_ID, options) {
-    // Cache for PoolContext instances (avoids re-deriving PDAs/ATAs)
-    this.poolContextCache = /* @__PURE__ */ new Map();
-    this.connection = connection;
-    this.programId = programId;
-    const [vaultPda, vaultBump] = deriveVaultPda(programId);
-    this.vaultPda = vaultPda;
-    this.vaultBump = vaultBump;
-    this.program = createProgram(connection);
-    this.jupiterApiKey = options?.jupiterApiKey;
-  }
-  static mainnet(connection, options) {
-    return new _JlpdClient(connection, JLPD_PROGRAM_ID, options);
-  }
-  static devnet(connection, options) {
-    const devnetProgramId = new PublicKey8(
-      "AcVcAihjB9Z3Lg3ZiboWxni2sTzXUrrsF3unGX4ntn6p"
-    );
-    return new _JlpdClient(connection, devnetProgramId, options);
-  }
-  // Fetch vault account
-  async fetchVault() {
-    const accountInfo = await this.connection.getAccountInfo(this.vaultPda);
-    if (!accountInfo) return null;
-    return parseVault(accountInfo.data);
-  }
-  // Fetch STV by base mint
-  async fetchStv(baseMint) {
-    const [stvPda] = deriveStvPda(baseMint, this.programId);
-    const accountInfo = await this.connection.getAccountInfo(stvPda);
-    if (!accountInfo) return null;
-    return parseStv(accountInfo.data);
-  }
-  // Fetch exchange rate for a pool
-  async fetchExchangeRate(poolName) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    if (!pool.hasJupiterLend) {
-      return {
-        rate: 1,
-        rawRate: BigInt(EXCHANGE_RATE_PRECISION),
-        storedRate: 1,
-        staleness: 0,
-        isFresh: true
-      };
-    }
-    const accounts = await this.connection.getMultipleAccountsInfo([
-      pool.lending,
-      pool.rewardsRateModel,
-      pool.fTokenMint
-    ]);
-    const [lendingInfo, rewardsInfo, mintInfo] = accounts;
-    if (!lendingInfo || !rewardsInfo || !mintInfo) {
-      throw new JlpdClientError("Failed to fetch Jupiter Lend accounts");
-    }
-    const lendingData = parseLendingAccount(lendingInfo.data);
-    const rewardsData = parseRewardsRateModel(rewardsInfo.data);
-    const slot = await this.connection.getSlot();
-    const timestamp = await this.connection.getBlockTime(slot);
-    if (!timestamp) throw new JlpdClientError("Failed to get block time");
-    const supply = mintInfo.data.readBigUInt64LE(36);
-    const rawRate = calculateExchangeRate(
-      lendingData.tokenExchangePrice,
-      rewardsData.yearlyReward,
-      BigInt(timestamp),
-      lendingData.lastUpdateTimestamp,
-      supply
-    );
-    const rate = Number(rawRate) / EXCHANGE_RATE_PRECISION;
-    const storedRate = Number(lendingData.tokenExchangePrice) / EXCHANGE_RATE_PRECISION;
-    const staleness = timestamp - Number(lendingData.lastUpdateTimestamp);
-    return {
-      rate,
-      rawRate,
-      storedRate,
-      staleness,
-      isFresh: staleness < 300
-    };
-  }
-  /**
-   * Calculate APY based on PPS growth over time
-   *
-   * @param poolName Pool to calculate APY for
-   * @param startPps PPS at the start of the period (as BN with 9 decimals)
-   * @param startTime Unix timestamp (seconds) when startPps was recorded
-   * @returns APY as a decimal (e.g., 0.12 = 12% APY)
-   *
-   * @example
-   * ```typescript
-   * // Calculate APY from a week ago
-   * const startPps = new BN("1050000000"); // 1.05 (9 decimals)
-   * const startTime = Math.floor(Date.now() / 1000) - 7 * 24 * 60 * 60;
-   * const apy = await client.calculateApy("SOL", startPps, startTime);
-   * console.log(`APY: ${(apy * 100).toFixed(2)}%`);
-   * ```
-   */
-  async calculateApy(poolName, startPps, startTime) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    const [stv, slot] = await Promise.all([
-      this.fetchStv(pool.mint),
-      this.connection.getSlot()
-    ]);
-    if (!stv) throw new JlpdClientError(`STV not found for pool: ${poolName}`);
-    const currentTime = await this.connection.getBlockTime(slot);
-    if (!currentTime) throw new JlpdClientError("Failed to get block time");
-    const currentPps = stv.pps;
-    const startPpsNum = Number(startPps.toString()) / PPS_DECIMALS;
-    const currentPpsNum = Number(currentPps.toString()) / PPS_DECIMALS;
-    const timeElapsed = currentTime - startTime;
-    if (timeElapsed <= 0) {
-      throw new JlpdClientError("Start time must be in the past");
-    }
-    const SECONDS_PER_YEAR2 = 365.25 * 24 * 60 * 60;
-    const ppsGrowthRatio = currentPpsNum / startPpsNum;
-    if (ppsGrowthRatio <= 0) {
-      return -1;
-    }
-    const annualizationFactor = SECONDS_PER_YEAR2 / timeElapsed;
-    const apy = Math.pow(ppsGrowthRatio, annualizationFactor) - 1;
-    return apy;
-  }
-  /**
-   * Calculate simple APY (non-compounded) based on PPS growth
-   *
-   * @param poolName Pool to calculate APY for
-   * @param startPps PPS at the start of the period
-   * @param startTime Unix timestamp when startPps was recorded
-   * @returns Simple APY as a decimal
-   */
-  async calculateSimpleApy(poolName, startPps, startTime) {
-    const pool = getPoolByName(poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${poolName}`);
-    const [stv, slot] = await Promise.all([
-      this.fetchStv(pool.mint),
-      this.connection.getSlot()
-    ]);
-    if (!stv) throw new JlpdClientError(`STV not found for pool: ${poolName}`);
-    const currentTime = await this.connection.getBlockTime(slot);
-    if (!currentTime) throw new JlpdClientError("Failed to get block time");
-    const startPpsNum = Number(startPps.toString()) / PPS_DECIMALS;
-    const currentPpsNum = Number(stv.pps.toString()) / PPS_DECIMALS;
-    const timeElapsed = currentTime - startTime;
-    if (timeElapsed <= 0) {
-      throw new JlpdClientError("Start time must be in the past");
-    }
-    const SECONDS_PER_YEAR2 = 365.25 * 24 * 60 * 60;
-    const growthRate = (currentPpsNum - startPpsNum) / startPpsNum;
-    const simpleApy = growthRate * (SECONDS_PER_YEAR2 / timeElapsed);
-    return simpleApy;
-  }
-  // Get pool context for pool-specific operations (cached)
-  pool(poolNameOrMint) {
-    const key = typeof poolNameOrMint === "string" ? poolNameOrMint : poolNameOrMint.toBase58();
-    let ctx = this.poolContextCache.get(key);
-    if (!ctx) {
-      const pool = typeof poolNameOrMint === "string" ? getPoolByName(poolNameOrMint) : getPoolByMint(poolNameOrMint);
-      if (!pool) throw new JlpdClientError(`Unknown pool: ${key}`);
-      ctx = new PoolContext(this, pool);
-      this.poolContextCache.set(key, ctx);
-      if (typeof poolNameOrMint === "string") {
-        this.poolContextCache.set(pool.mint.toBase58(), ctx);
-      } else {
-        this.poolContextCache.set(pool.name, ctx);
-      }
-    }
-    return ctx;
-  }
-  // Get swap context for swap operations
-  swap() {
-    return new SwapContext(this);
-  }
-  // Get admin context for admin operations
-  admin() {
-    return new AdminContext(this);
-  }
-  // Build a versioned transaction
-  async buildTransaction(payer, ixs, alts = []) {
-    const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
-    const message = new TransactionMessage({
-      payerKey: payer,
-      recentBlockhash: blockhash,
-      instructions: ixs
-    }).compileToV0Message(alts);
-    return new VersionedTransaction(message);
-  }
-};
-var PoolContext = class {
-  constructor(client, pool) {
-    this.client = client;
-    this.pool = pool;
-    const [pda, bump] = deriveStvPda(pool.mint, client.programId);
-    this.stvPda = pda;
-    this.stvBump = bump;
-    const vaultAtas = deriveVaultAtas(pool.fTokenMint, MINTS.JLP, client.vaultPda);
-    this.vaultStagingAta = vaultAtas.stagingAta;
-    this.vaultJlpAta = vaultAtas.jlpAta;
-    this.vaultBaseAta = deriveAta(pool.mint, client.vaultPda, true);
-    const stvAtas = deriveStvAtas(pool.mint, pool.fTokenMint, this.stvPda);
-    this.stvBaseAta = stvAtas.baseAta;
-    this.stvJlxAta = stvAtas.jlxAta;
-  }
-  // Deposit base asset and receive jvX shares
-  async deposit(params) {
-    if (params.amount.isZero() || params.amount.isNeg()) {
-      throw new JlpdClientError("Deposit amount must be positive");
-    }
-    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 userAtas = deriveUserAtas(this.pool.mint, stv.jvMint, params.user);
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createDepositInstruction(
-      this.client.program,
-      params.amount,
-      {
-        user: params.user,
-        jlpVault: this.client.vaultPda,
-        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,
-        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,
-      recentBlockhash: blockhash,
-      instructions: [ix]
-    }).compileToV0Message();
-    return new VersionedTransaction(message);
-  }
-  // 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");
-    }
-    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 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 ix = await createRequestWithdrawInstruction(
-      this.client.program,
-      { 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,
-        jvMint: stv.jvMint,
-        userBaseAta: userAtas.baseAta,
-        stvBaseAta: this.stvBaseAta,
-        withdrawRequest: withdrawRequestPda,
-        requestJvxAta,
-        tokenProgram: TOKEN_PROGRAM_ID2
-      }
-    );
-    const message = new TransactionMessage({
-      payerKey: params.user,
-      recentBlockhash: blockhash,
-      instructions: [ix]
-    }).compileToV0Message();
-    return new VersionedTransaction(message);
-  }
-  // Jupiter Earn deposit/withdraw
-  async jupEarn(params) {
-    if (!this.pool.hasJupiterLend) {
-      throw new JlpdClientError(`Pool ${this.pool.name} does not support Jupiter Earn`);
-    }
-    const remainingAccounts = params.direction === "Deposit" ? buildJupEarnDepositAccounts(this.pool, this.stvPda, this.stvBaseAta, this.stvJlxAta) : buildJupEarnWithdrawAccounts(this.pool, this.stvPda, this.stvJlxAta, this.stvBaseAta);
-    const ix = await createJupEarnInstruction(
-      this.client.program,
-      { direction: params.direction, amount: params.amount },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta
-      },
-      remainingAccounts
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Move jlX between STV and vault
-  async moveJlx(params) {
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createMoveJlxInstruction(
-      this.client.program,
-      { amountJlx: params.jlxAmount, direction: params.direction },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        stvJlxAta: this.stvJlxAta,
-        vaultStagingAta: this.vaultStagingAta,
-        tokenProgram: TOKEN_PROGRAM_ID2
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Claim fees
-  async claimFees(params) {
-    const [vault, stv] = await Promise.all([
-      this.client.fetchVault(),
-      this.client.fetchStv(this.pool.mint)
-    ]);
-    if (!vault) throw new JlpdClientError("Vault not found");
-    if (!stv) throw new JlpdClientError("STV not found");
-    const feeReceiverJlxAta = getAssociatedTokenAddressSync2(
-      this.pool.fTokenMint,
-      vault.feeReceiver,
-      true
-    );
-    const erAccounts = this.pool.hasJupiterLend ? buildExchangeRateAccounts(this.pool) : null;
-    const ix = await createClaimFeesInstruction(
-      this.client.program,
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda,
-        baseMint: this.pool.mint,
-        jlMint: this.pool.fTokenMint,
-        jvMint: stv.jvMint,
-        stvBaseAta: this.stvBaseAta,
-        stvJlxAta: this.stvJlxAta,
-        feeReceiverJlxAta,
-        tokenProgram: TOKEN_PROGRAM_ID2
-      },
-      erAccounts ? [
-        { pubkey: erAccounts.lending, isSigner: false, isWritable: false },
-        { pubkey: erAccounts.rewardsRateModel, isSigner: false, isWritable: false }
-      ] : []
-    );
-    return this.client.buildTransaction(params.manager, [ix]);
-  }
-  // Update STV parameters (admin only)
-  async updateStv(params) {
-    const stv = await this.client.fetchStv(this.pool.mint);
-    if (!stv) throw new JlpdClientError("STV not found");
-    const ix = await createUpdateStvInstruction(
-      this.client.program,
-      {
-        mgmtFeeBps: params.mgmtFeeBps ?? stv.mgmtFeeBps,
-        perfFeeBps: params.perfFeeBps ?? stv.perfFeeBps,
-        flags: params.flags ?? stv.flags,
-        maxDeposit: params.maxDeposit ?? stv.maxDeposit,
-        minDeposit: params.minDeposit ?? stv.minDeposit,
-        jlMint: params.jlMint ?? null,
-        pps: params.pps ?? null,
-        hwm: params.hwm ?? null,
-        baseLoaned: params.baseLoaned ?? null,
-        epochSec: params.epochSec ?? null
-      },
-      {
-        admin: params.admin,
-        jlpVault: this.client.vaultPda,
-        stv: this.stvPda
-      }
-    );
-    return this.client.buildTransaction(params.admin, [ix]);
-  }
-};
-var SwapContext = class {
-  constructor(client) {
-    this.client = client;
-  }
-  // Get a quote for jlX <-> JLP swap
-  async quoteJlxJlp(params) {
-    const poolConfig = getPoolByName(params.pool);
-    if (!poolConfig) throw new JlpdClientError(`Unknown pool: ${params.pool}`);
-    const swapMint = poolConfig.jupDirectSwap ? poolConfig.fTokenMint : poolConfig.mint;
-    const inputMint = params.direction === "JlxToJlp" ? swapMint : MINTS.JLP;
-    const outputMint = params.direction === "JlxToJlp" ? MINTS.JLP : swapMint;
-    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 BN5(quote.inAmount),
-      outAmount: new BN5(quote.outAmount),
-      minOutAmount: new BN5(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 <-> JLP swap transaction
-  async swapJlxJlp(params) {
-    const poolConfig = getPoolByName(params.pool);
-    if (!poolConfig) throw new JlpdClientError(`Unknown pool: ${params.pool}`);
-    const poolCtx = this.client.pool(params.pool);
-    const computeIx = ComputeBudgetProgram.setComputeUnitLimit({
-      units: params.quote.computeUnitLimit
-    });
-    const jupiterProgram = JUPITER_SWAP_PROGRAM_ID;
-    const swapIx = await createSwapJlxJlpInstruction(
-      this.client.program,
-      {
-        stvIndex: poolConfig.stvIndex,
-        direction: params.direction,
-        amountIn: params.amountIn,
-        expectedAmountOut: params.expectedOut,
-        jupiterData: params.quote.jupiterData
-      },
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        vaultJlxAta: poolConfig.jupDirectSwap ? poolCtx.vaultStagingAta : poolCtx.vaultBaseAta,
-        vaultJlpAta: poolCtx.vaultJlpAta,
-        jlpMint: MINTS.JLP,
-        tokenProgram: TOKEN_PROGRAM_ID2,
-        jupiterProgram
-      },
-      params.quote.remainingAccounts
-    );
-    const { blockhash } = await this.client.connection.getLatestBlockhash("confirmed");
-    const message = new TransactionMessage({
-      payerKey: params.manager,
-      recentBlockhash: blockhash,
-      instructions: [computeIx, swapIx]
-    }).compileToV0Message(params.quote.addressLookupTables);
-    return new VersionedTransaction(message);
-  }
-};
-var AdminContext = class {
-  constructor(client) {
-    this.client = client;
-  }
-  // Initialize or update vault
-  async initOrUpdateVault(params) {
-    const currentVault = await this.client.fetchVault();
-    const ix = await createInitOrUpdateVaultInstruction(
-      this.client.program,
-      {
-        jlpMint: params.jlpMint ?? null,
-        baseAssetMints: params.baseAssetMints ?? null,
-        jlxAssetMints: params.jlxAssetMints ?? null,
-        newAdmin: params.newAdmin ?? null,
-        manager: params.manager ?? currentVault.manager,
-        feeReceiver: params.feeReceiver ?? currentVault.feeReceiver,
-        flags: params.flags ?? currentVault.flags,
-        jlpSlippageBps: params.jlpSlippageBps ?? currentVault.jlpSlippageBps,
-        oracleStalenessThreshold: params.oracleStalenessThreshold ?? null
-      },
-      {
-        admin: params.admin
-      }
-    );
-    return this.client.buildTransaction(params.admin, [ix]);
-  }
-  // Initialize STV
-  async initializeStv(params, jvMintKeypair) {
-    const pool = getPoolByName(params.poolName);
-    if (!pool) throw new JlpdClientError(`Unknown pool: ${params.poolName}`);
-    const ix = await createInitializeStvInstruction(
-      this.client.program,
-      {
-        mgmtFeeBps: params.mgmtFeeBps,
-        perfFeeBps: params.perfFeeBps,
-        maxDeposit: params.maxDeposit,
-        minDeposit: params.minDeposit,
-        epochSec: params.withdrawEpochSec
-      },
-      {
-        admin: params.admin,
-        jlpVault: this.client.vaultPda,
-        baseMint: pool.mint,
-        jlMint: pool.fTokenMint,
-        jvMint: jvMintKeypair,
-        tokenProgram: TOKEN_PROGRAM_ID2
-      }
-    );
-    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"];
-    const pools = poolNames.map((name) => {
-      const pool = getPoolByName(name);
-      if (!pool) throw new JlpdClientError(`Unknown pool: ${name}`);
-      return pool;
-    });
-    const stvPdas = pools.map((p) => deriveStvPda(p.mint, this.client.programId)[0]);
-    const stagingAtas = pools.map(
-      (p) => getAssociatedTokenAddressSync2(p.fTokenMint, this.client.vaultPda, true)
-    );
-    const lendingAccounts = pools.map((p) => ({
-      pubkey: p.hasJupiterLend ? p.lending : PublicKey8.default,
-      isSigner: false,
-      isWritable: false
-    }));
-    const rewardsAccounts = pools.map((p) => ({
-      pubkey: p.hasJupiterLend ? p.rewardsRateModel : PublicKey8.default,
-      isSigner: false,
-      isWritable: false
-    }));
-    const mintAccounts = pools.map((p) => ({
-      pubkey: p.fTokenMint,
-      isSigner: false,
-      isWritable: false
-    }));
-    const remainingAccounts = [...lendingAccounts, ...rewardsAccounts, ...mintAccounts];
-    const ix = await createSettleYieldInstruction(
-      this.client.program,
-      {},
-      {
-        manager: params.manager,
-        jlpVault: this.client.vaultPda,
-        vaultJlpAta: getAssociatedTokenAddressSync2(MINTS.JLP, this.client.vaultPda, true),
-        jlpMint: MINTS.JLP,
-        stvBtc: stvPdas[0],
-        stvEth: stvPdas[1],
-        stvSol: stvPdas[2],
-        stvUsdc: stvPdas[3],
-        stvJupusd: stvPdas[4],
-        stagingBtc: stagingAtas[0],
-        stagingEth: stagingAtas[1],
-        stagingSol: stagingAtas[2],
-        stagingUsdc: stagingAtas[3],
-        stagingJupusd: stagingAtas[4],
-        oracleBtc: ORACLES.DOVES_BTC_USD,
-        oracleEth: ORACLES.DOVES_ETH_USD,
-        oracleSol: ORACLES.DOVES_SOL_USD,
-        jlpPool: JLP_POOL_PUBKEY,
-        jlpMintAccount: MINTS.JLP
-      },
-      remainingAccounts
-    );
-    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,
-  FLAG_DEPOSITS_DISABLED,
-  FLAG_JLP_DISABLED,
-  FLAG_PAUSED,
-  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,
-  JUPITER_LEND_PROGRAM_ID2 as JUP_LEND_PROGRAM_ID,
-  JlpdClient,
-  JlpdClientError,
-  LENDING_ADMIN,
-  LIQUIDITY_PROGRAM_ID,
-  LIQUIDITY_SINGLETON,
-  MINTS,
-  ORACLES,
-  POOLS,
-  PPS_DECIMALS,
-  PoolContext,
-  SEED_JLP_VAULT,
-  SEED_STV,
-  SEED_WITHDRAW_REQUEST,
-  STV_ACCOUNT_SIZE,
-  STV_DATA_SIZE,
-  STV_DISCRIMINATOR,
-  STV_INDEX,
-  SwapContext,
-  USDC_POOL,
-  WBTC_POOL,
-  WETH_POOL,
-  WITHDRAW_REQUEST_ACCOUNT_SIZE,
-  WITHDRAW_REQUEST_DATA_SIZE,
-  WITHDRAW_REQUEST_DISCRIMINATOR,
-  WSOL_POOL,
-  baseToJlx,
-  baseToShares,
-  buildExchangeRateAccounts,
-  buildJupEarnDepositAccounts,
-  buildJupEarnWithdrawAccounts,
-  buildSwapData,
-  calculateExchangeRate,
-  calculateNav,
-  calculatePps,
-  clearAtaCache,
-  clearPdaCache,
-  createClaimFeesInstruction,
-  createClaimWithdrawInstruction,
-  createDepositInstruction,
-  createInitOrUpdateVaultInstruction,
-  createInitializeStvInstruction,
-  createJupEarnInstruction,
-  createMoveJlxInstruction,
-  createProcessEpochInstruction,
-  createProgram,
-  createRequestWithdrawInstruction,
-  createSettleYieldInstruction,
-  createSwapJlxJlpInstruction,
-  createUpdateStvInstruction,
-  deriveAta,
-  deriveStvAtas,
-  deriveStvPda,
-  deriveUserAtas,
-  deriveVaultAtas,
-  deriveVaultPda,
-  deriveWithdrawRequestPda,
-  fetchAddressLookupTables,
-  fetchJlpRate,
-  fetchJupiterPriceUsd,
-  getJupiterQuote,
-  getJupiterSwapInstructions,
-  getPoolByMint,
-  getPoolByName,
-  jlxToBase,
-  parseLendingAccount,
-  parseRewardsRateModel,
-  parseStv,
-  parseSwapRemainingAccounts,
-  parseVault,
-  parseWithdrawRequest,
-  sharesToBase
-};