@0dotxyz/p0-ts-sdk 2.5.0 → 2.6.0-alpha.0

package/dist/index.cjs

@@ -20351,6 +20351,9 @@ var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
   TransactionType2["INITIALIZE_STAKED_POOL"] = "INITIALIZE_STAKED_POOL";
   TransactionType2["ADD_STAKED_BANK"] = "ADD_STAKED_BANK";
   TransactionType2["MERGE_STAKE_ACCOUNTS"] = "MERGE_STAKE_ACCOUNTS";
+  TransactionType2["VAULT_DEPOSIT"] = "VAULT_DEPOSIT";
+  TransactionType2["VAULT_WITHDRAW"] = "VAULT_WITHDRAW";
+  TransactionType2["VAULT_COMPLETE_WITHDRAWAL"] = "VAULT_COMPLETE_WITHDRAWAL";
   TransactionType2["STAKE_TO_STAKE"] = "STAKE_TO_STAKE";
   TransactionType2["MINT_LST_NATIVE"] = "MINT_LST_NATIVE";
   TransactionType2["SWAP_TO_SOL"] = "SWAP_TO_SOL";
@@ -20419,6 +20422,16 @@ var TransactionConfigMap = {
   ["INITIALIZE_STAKED_POOL" /* INITIALIZE_STAKED_POOL */]: { label: () => "Initialize stake pool" },
   ["ADD_STAKED_BANK" /* ADD_STAKED_BANK */]: { label: () => "Create staked asset bank" },
   ["MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */]: { label: () => "Merge stake accounts" },
+  // GAMMA VAULT ACTIONS
+  ["VAULT_DEPOSIT" /* VAULT_DEPOSIT */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Deposit ${amount} ${token} into vault` : "Deposit into vault"
+  },
+  ["VAULT_WITHDRAW" /* VAULT_WITHDRAW */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Withdraw ${amount} ${token} from vault` : "Withdraw from vault"
+  },
+  ["VAULT_COMPLETE_WITHDRAWAL" /* VAULT_COMPLETE_WITHDRAWAL */]: {
+    label: () => "Claim vault withdrawal"
+  },
   // LST (Liquid Staking Tokens)
   ["STAKE_TO_STAKE" /* STAKE_TO_STAKE */]: { label: () => "Convert stake" },
   ["MINT_LST_NATIVE" /* MINT_LST_NATIVE */]: { label: () => "Mint LST" },
@@ -20781,16 +20794,16 @@ var instructions = {
 var instructions_default = instructions;
 function serializeBankConfigOpt(bankConfigOpt) {
   const toWrappedI80F48 = (value) => value && bigNumberToWrappedI80F48(value);
-  const toBN = (value) => value && new BN9__default.default(value.toString());
+  const toBN2 = (value) => value && new BN9__default.default(value.toString());
   return {
     assetWeightInit: toWrappedI80F48(bankConfigOpt.assetWeightInit),
     assetWeightMaint: toWrappedI80F48(bankConfigOpt.assetWeightMaint),
     liabilityWeightInit: toWrappedI80F48(bankConfigOpt.liabilityWeightInit),
     liabilityWeightMaint: toWrappedI80F48(bankConfigOpt.liabilityWeightMaint),
-    depositLimit: toBN(bankConfigOpt.depositLimit),
-    borrowLimit: toBN(bankConfigOpt.borrowLimit),
+    depositLimit: toBN2(bankConfigOpt.depositLimit),
+    borrowLimit: toBN2(bankConfigOpt.borrowLimit),
     riskTier: bankConfigOpt.riskTier && serializeRiskTier(bankConfigOpt.riskTier),
-    totalAssetValueInitLimit: toBN(bankConfigOpt.totalAssetValueInitLimit),
+    totalAssetValueInitLimit: toBN2(bankConfigOpt.totalAssetValueInitLimit),
     assetTag: bankConfigOpt.assetTag !== null ? Number(bankConfigOpt.assetTag) : 0,
     interestRateConfig: bankConfigOpt.interestRateConfig && {
       insuranceFeeFixedApr: toWrappedI80F48(
@@ -62801,430 +62814,3803 @@ async function resolveExponentClmmTradePtContext(params) {
     pt: { mint: market.mintPt, decimals: ptDecimals, tokenProgram: ptTokenProgram }
   };
 }
+var GAMMA_VAULT_PROGRAM_ID = new web3_js.PublicKey(
+  "gvvtqvEmwQDnFwEvLJzzyweABcXV7HAYsTwTgztEHWJ"
+);
+var SEED_WITHDRAWAL_POLICY = "withdrawal_policy";
+var SEED_DEPOSIT_RECEIPT = "deposit_receipt";
+var SEED_WITHDRAW_ESCROW = "withdraw_escrow";
+var SEED_WITHDRAW_RECEIPT = "withdraw_receipt";
 
-// src/vendor/klend/utils/klend/interest-rate.utils.ts
-function getKaminoTotalSupply(reserve) {
-  const liquidityAvailableAmount = new Decimal3__default.default(reserve.liquidity.availableAmount.toString());
-  const borrowedAmount = new Fraction(reserve.liquidity.borrowedAmountSf).toDecimal();
-  const accumulatedProtocolFee = new Fraction(
-    reserve.liquidity.accumulatedProtocolFeesSf
-  ).toDecimal();
-  const accumulatedReferrerFees = new Fraction(
-    reserve.liquidity.accumulatedReferrerFeesSf
-  ).toDecimal();
-  const pendingReferrerFees = new Fraction(reserve.liquidity.pendingReferrerFeesSf).toDecimal();
-  return liquidityAvailableAmount.add(borrowedAmount).sub(accumulatedProtocolFee).sub(accumulatedReferrerFees).sub(pendingReferrerFees);
-}
-function scaledSupplies(state) {
-  const liqMintDecimals = new Decimal3__default.default(state.liquidity.mintDecimals.toString());
-  const totalSupplyLamports = getKaminoTotalSupply(state);
-  const mintTotalSupplyLam = new Decimal3__default.default(state.collateral.mintTotalSupply.toString());
-  const liqScale = new Decimal3__default.default(10).pow(liqMintDecimals);
-  const collScale = new Decimal3__default.default(10).pow(liqMintDecimals);
-  const totalSupply = totalSupplyLamports.div(liqScale);
-  const totalCollateral = mintTotalSupplyLam.div(collScale);
-  return [totalSupply, totalCollateral];
-}
-
-// src/vendor/klend/utils/farms/serialize.utils.ts
-function kaminoFarmStateToDto(farmState) {
-  return {
-    token: {
-      mint: farmState.token.mint.toBase58(),
-      decimals: farmState.token.decimals.toString()
-    },
-    rewardInfos: farmState.rewardInfos.map((item) => ({
-      token: {
-        mint: item.token.mint.toBase58(),
-        decimals: item.token.decimals.toString()
-      },
-      rewardsAvailable: item.rewardsAvailable.toString(),
-      rewardsPerSecondDecimals: item.rewardsPerSecondDecimals,
-      rewardScheduleCurve: {
-        points: item.rewardScheduleCurve.points.map((p) => ({
-          tsStart: p.tsStart.toString(),
-          rewardPerTimeUnit: p.rewardPerTimeUnit.toString()
-        }))
-      }
-    }))
-  };
-}
-var farmDiscriminator = Buffer.from([198, 102, 216, 74, 63, 66, 163, 190]);
-var farmLayout = borsh.struct([
-  borsh.publicKey("farmAdmin"),
-  borsh.publicKey("globalConfig"),
-  borsh.struct(
-    [
-      borsh.publicKey("mint"),
-      borsh.u64("decimals"),
-      borsh.publicKey("tokenProgram"),
-      borsh.array(borsh.u64(), 6, "padding")
-    ],
-    "token"
-  ),
-  borsh.array(
-    borsh.struct([
-      borsh.struct(
-        [
-          borsh.publicKey("mint"),
-          borsh.u64("decimals"),
-          borsh.publicKey("tokenProgram"),
-          borsh.array(borsh.u64(), 6, "padding")
-        ],
-        "token"
-      ),
-      borsh.publicKey("rewardsVault"),
-      borsh.u64("rewardsAvailable"),
-      borsh.struct(
-        [
-          borsh.array(
-            borsh.struct([borsh.u64("tsStart"), borsh.u64("rewardPerTimeUnit")]),
-            20,
-            "points"
-          )
-        ],
-        "rewardScheduleCurve"
-      ),
-      borsh.u64("minClaimDurationSeconds"),
-      borsh.u64("lastIssuanceTs"),
-      borsh.u64("rewardsIssuedUnclaimed"),
-      borsh.u64("rewardsIssuedCumulative"),
-      borsh.u128("rewardPerShareScaled"),
-      borsh.u64("placeholder0"),
-      borsh.u8("rewardType"),
-      borsh.u8("rewardsPerSecondDecimals"),
-      borsh.array(borsh.u8(), 6, "padding0"),
-      borsh.array(borsh.u64(), 20, "padding1")
-    ]),
-    10,
-    "rewardInfos"
-  ),
-  borsh.u64("numRewardTokens"),
-  borsh.u64("numUsers"),
-  borsh.u64("totalStakedAmount"),
-  borsh.publicKey("farmVault"),
-  borsh.publicKey("farmVaultsAuthority"),
-  borsh.u64("farmVaultsAuthorityBump"),
-  borsh.publicKey("delegateAuthority"),
-  borsh.u8("timeUnit"),
-  borsh.u8("isFarmFrozen"),
-  borsh.u8("isFarmDelegated"),
-  borsh.array(borsh.u8(), 5, "padding0"),
-  borsh.publicKey("withdrawAuthority"),
-  borsh.u32("depositWarmupPeriod"),
-  borsh.u32("withdrawalCooldownPeriod"),
-  borsh.u128("totalActiveStakeScaled"),
-  borsh.u128("totalPendingStakeScaled"),
-  borsh.u64("totalPendingAmount"),
-  borsh.u64("slashedAmountCurrent"),
-  borsh.u64("slashedAmountCumulative"),
-  borsh.publicKey("slashedAmountSpillAddress"),
-  borsh.u64("lockingMode"),
-  borsh.u64("lockingStartTimestamp"),
-  borsh.u64("lockingDuration"),
-  borsh.u64("lockingEarlyWithdrawalPenaltyBps"),
-  borsh.u64("depositCapAmount"),
-  borsh.publicKey("scopePrices"),
-  borsh.u64("scopeOraclePriceId"),
-  borsh.u64("scopeOracleMaxAge"),
-  borsh.publicKey("pendingFarmAdmin"),
-  borsh.publicKey("strategyId"),
-  borsh.publicKey("delegatedRpsAdmin"),
-  borsh.publicKey("vaultId"),
-  borsh.publicKey("secondDelegatedAuthority"),
-  borsh.array(borsh.u64(), 74, "padding")
-]);
-function decodeFarmDataRaw(data) {
-  if (!data.slice(0, 8).equals(farmDiscriminator)) {
-    throw new Error("invalid account discriminator");
-  }
-  const dec = farmLayout.decode(data.slice(8));
-  return dec;
-}
-function dtoToKaminoFarmState(dto) {
-  return {
-    token: {
-      mint: new web3_js.PublicKey(dto.token.mint),
-      decimals: new BN9__default.default(dto.token.decimals)
-    },
-    rewardInfos: dto.rewardInfos.map((item) => ({
-      token: {
-        mint: new web3_js.PublicKey(item.token.mint),
-        decimals: new BN9__default.default(item.token.decimals)
-      },
-      rewardsAvailable: new BN9__default.default(item.rewardsAvailable),
-      rewardsPerSecondDecimals: item.rewardsPerSecondDecimals,
-      rewardScheduleCurve: {
-        points: item.rewardScheduleCurve.points.map((p) => ({
-          tsStart: new BN9__default.default(p.tsStart),
-          rewardPerTimeUnit: new BN9__default.default(p.rewardPerTimeUnit)
-        }))
-      }
-    }))
-  };
-}
-var KAMINO_PROGRAM_ID = new web3_js.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD");
-var FARMS_PROGRAM_ID2 = new web3_js.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
-function encodeU64(value) {
-  const buf = Buffer.alloc(8);
-  value.toArrayLike(Buffer, "le", 8).copy(buf);
-  return buf;
-}
-function encodeU8(value) {
-  const buf = Buffer.alloc(1);
-  buf.writeUInt8(value, 0);
-  return buf;
-}
-function encodeBool(value) {
-  const buf = Buffer.alloc(1);
-  buf.writeUInt8(value ? 1 : 0, 0);
-  return buf;
-}
-function encodeOptionBool(value) {
-  if (value === null || value === void 0) {
-    return Buffer.from([0]);
-  }
-  return Buffer.concat([Buffer.from([1]), encodeBool(value)]);
-}
-function encodeOptionU8(value) {
-  if (value === null || value === void 0) {
-    return Buffer.from([0]);
-  }
-  return Buffer.concat([Buffer.from([1]), encodeU8(value)]);
-}
-function encodePublicKey(pubkey) {
-  return Buffer.from(pubkey.toBytes());
-}
-var DISCRIMINATORS = {
-  MARGINFI_ACCOUNT_INITIALIZE: Buffer.from([43, 78, 61, 255, 148, 52, 249, 154]),
-  KAMINO_DEPOSIT: Buffer.from([237, 8, 188, 187, 115, 99, 49, 85]),
-  LENDING_ACCOUNT_DEPOSIT: Buffer.from([171, 94, 235, 103, 82, 64, 212, 140]),
-  LENDING_ACCOUNT_REPAY: Buffer.from([79, 209, 172, 177, 222, 51, 173, 151]),
-  KAMINO_WITHDRAW: Buffer.from([199, 101, 41, 45, 213, 98, 224, 200]),
-  LENDING_ACCOUNT_WITHDRAW: Buffer.from([36, 72, 74, 19, 210, 210, 192, 192]),
-  LENDING_ACCOUNT_BORROW: Buffer.from([4, 126, 116, 53, 48, 5, 212, 31]),
-  LENDING_ACCOUNT_LIQUIDATE: Buffer.from([214, 169, 151, 213, 251, 167, 86, 219]),
-  LENDING_POOL_ADD_BANK: Buffer.from([215, 68, 72, 78, 208, 218, 103, 182]),
-  LENDING_POOL_CONFIGURE_BANK: Buffer.from([121, 173, 156, 40, 93, 148, 56, 237]),
-  LENDING_ACCOUNT_START_FLASHLOAN: Buffer.from([14, 131, 33, 220, 81, 186, 180, 107]),
-  LENDING_ACCOUNT_END_FLASHLOAN: Buffer.from([105, 124, 201, 106, 153, 2, 8, 156]),
-  TRANSFER_TO_NEW_ACCOUNT: Buffer.from([28, 79, 129, 231, 169, 69, 69, 65]),
-  MARGINFI_GROUP_INITIALIZE: Buffer.from([255, 67, 67, 26, 94, 31, 34, 20]),
-  MARGINFI_ACCOUNT_CLOSE: Buffer.from([186, 221, 93, 34, 50, 97, 194, 241]),
-  LENDING_POOL_ADD_BANK_PERMISSIONLESS: Buffer.from([127, 187, 121, 34, 187, 167, 238, 102]),
-  LENDING_POOL_CONFIGURE_BANK_ORACLE: Buffer.from([209, 82, 255, 171, 124, 21, 71, 81]),
-  LENDING_ACCOUNT_PULSE_HEALTH: Buffer.from([186, 52, 117, 97, 34, 74, 39, 253]),
-  LENDING_ACCOUNT_SORT_BALANCES: Buffer.from([187, 194, 110, 84, 82, 170, 204, 9]),
-  DRIFT_DEPOSIT: Buffer.from([252, 63, 250, 201, 98, 55, 130, 12]),
-  DRIFT_WITHDRAW: Buffer.from([86, 59, 186, 123, 183, 181, 234, 137])
-};
-function makeInitMarginfiAccountIx2(programId, accounts) {
-  const keys = [
-    { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: true, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
-    {
-      pubkey: accounts.systemProgram || web3_js.SystemProgram.programId,
-      isSigner: false,
-      isWritable: false
-    }
-  ];
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data: DISCRIMINATORS.MARGINFI_ACCOUNT_INITIALIZE
-  });
-}
-function makeDepositIx2(programId, accounts, args, remainingAccounts = []) {
-  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
-  const keys = [
-    { pubkey: accounts.group, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.bank, isSigner: false, isWritable: true },
-    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
-    {
-      pubkey: accounts.liquidityVault ?? liquidityVault,
-      isSigner: false,
-      isWritable: true
-    },
-    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
-  ];
-  keys.push(...remainingAccounts);
-  const data = Buffer.concat([
-    DISCRIMINATORS.LENDING_ACCOUNT_DEPOSIT,
-    encodeU64(args.amount),
-    encodeOptionBool(args.depositUpToLimit ?? null)
-  ]);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data
-  });
-}
-function makeRepayIx2(programId, accounts, args, remainingAccounts = []) {
-  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
-  const keys = [
-    { pubkey: accounts.group, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.bank, isSigner: false, isWritable: true },
-    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
-    { pubkey: liquidityVault, isSigner: false, isWritable: true },
-    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
-  ];
-  keys.push(...remainingAccounts);
-  const data = Buffer.concat([
-    DISCRIMINATORS.LENDING_ACCOUNT_REPAY,
-    encodeU64(args.amount),
-    encodeOptionBool(args.repayAll ?? null)
-  ]);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data
-  });
-}
-function makeWithdrawIx2(programId, accounts, args, remainingAccounts = []) {
-  const [bankLiquidityVaultAuthority] = deriveBankLiquidityVaultAuthority(programId, accounts.bank);
-  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
-  const keys = [
-    { pubkey: accounts.group, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.bank, isSigner: false, isWritable: true },
-    {
-      pubkey: accounts.destinationTokenAccount,
-      isSigner: false,
-      isWritable: true
-    },
-    { pubkey: bankLiquidityVaultAuthority, isSigner: false, isWritable: false },
-    { pubkey: liquidityVault, isSigner: false, isWritable: true },
-    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
-  ];
-  keys.push(...remainingAccounts);
-  const data = Buffer.concat([
-    DISCRIMINATORS.LENDING_ACCOUNT_WITHDRAW,
-    encodeU64(args.amount),
-    encodeOptionBool(args.withdrawAll ?? null)
-  ]);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data
-  });
-}
-function makeBorrowIx2(programId, accounts, args, remainingAccounts = []) {
-  const [bankLiquidityVaultAuthority] = deriveBankLiquidityVaultAuthority(programId, accounts.bank);
-  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
-  const keys = [
-    { pubkey: accounts.group, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.bank, isSigner: false, isWritable: true },
-    {
-      pubkey: accounts.destinationTokenAccount,
-      isSigner: false,
-      isWritable: true
-    },
-    { pubkey: bankLiquidityVaultAuthority, isSigner: false, isWritable: false },
-    { pubkey: liquidityVault, isSigner: false, isWritable: true },
-    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
-  ];
-  keys.push(...remainingAccounts);
-  const data = Buffer.concat([DISCRIMINATORS.LENDING_ACCOUNT_BORROW, encodeU64(args.amount)]);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data
-  });
-}
-function makeBeginFlashLoanIx2(programId, accounts, args) {
-  const keys = [
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    {
-      pubkey: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
-      // hardcoded address from IDL
-      isSigner: false,
-      isWritable: false
-    }
-  ];
-  const data = Buffer.concat([
-    DISCRIMINATORS.LENDING_ACCOUNT_START_FLASHLOAN,
-    encodeU64(args.endIndex)
-  ]);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data
-  });
-}
-function makeEndFlashLoanIx2(programId, accounts, remainingAccounts = []) {
-  const keys = [
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false }
-  ];
-  keys.push(...remainingAccounts);
-  return new web3_js.TransactionInstruction({
-    keys,
-    programId,
-    data: DISCRIMINATORS.LENDING_ACCOUNT_END_FLASHLOAN
-  });
-}
-function makeKaminoDepositIx2(programId, accounts, args, remainingAccounts = []) {
-  const liquidityVaultAuthority = deriveBankLiquidityVaultAuthority(programId, accounts.bank)[0];
-  const liquidityVault = deriveBankLiquidityVault(programId, accounts.bank)[0];
-  const keys = [
-    { pubkey: accounts.group, isSigner: false, isWritable: false },
-    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
-    { pubkey: accounts.authority, isSigner: true, isWritable: false },
-    { pubkey: accounts.bank, isSigner: false, isWritable: true },
-    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
-    {
-      pubkey: liquidityVaultAuthority,
-      isSigner: false,
-      isWritable: true
-    },
-    { pubkey: liquidityVault, isSigner: false, isWritable: true },
-    { pubkey: accounts.integrationAcc2, isSigner: false, isWritable: true },
-    { pubkey: accounts.lendingMarket, isSigner: false, isWritable: false },
-    {
-      pubkey: accounts.lendingMarketAuthority,
-      isSigner: false,
-      isWritable: false
-    },
-    { pubkey: accounts.integrationAcc1, isSigner: false, isWritable: true },
-    { pubkey: accounts.mint, isSigner: false, isWritable: false },
+// src/vendor/gamma/idl/gamma-vault.json
+var gamma_vault_default = {
+  address: "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV",
+  metadata: {
+    name: "gamma_vault",
+    version: "2.0.0",
+    spec: "0.1.0",
+    description: "Gamma Protocol vault program \u2014 LP vaults with instant deposits, escrow withdrawals, and performance fees"
+  },
+  instructions: [
     {
-      pubkey: accounts.reserveLiquiditySupply,
-      isSigner: false,
-      isWritable: true
+      name: "assess_fees",
+      docs: [
+        "Assess scheduled performance fees (keeper)."
+      ],
+      discriminator: [
+        224,
+        15,
+        195,
+        19,
+        125,
+        145,
+        2,
+        100
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault",
+          writable: true
+        },
+        {
+          name: "shares_mint",
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "fee_recipient_account",
+          writable: true
+        },
+        {
+          name: "token_program"
+        }
+      ],
+      args: []
     },
     {
-      pubkey: accounts.reserveCollateralMint,
-      isSigner: false,
-      isWritable: true
+      name: "close_deposit_receipt",
+      docs: [
+        "Close a deposit receipt and reclaim rent."
+      ],
+      discriminator: [
+        216,
+        104,
+        127,
+        60,
+        88,
+        217,
+        184,
+        15
+      ],
+      accounts: [
+        {
+          name: "user",
+          docs: [
+            "User who owns the deposit receipt."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "The vault this receipt is associated with."
+          ]
+        },
+        {
+          name: "deposit_receipt",
+          docs: [
+            "Deposit receipt to close. Rent is returned to user."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        }
+      ],
+      args: []
     },
     {
-      pubkey: accounts.reserveDestinationDepositCollateral,
-      isSigner: false,
-      isWritable: true
-    }
-  ];
-  if (accounts.obligationFarmUserState) {
-    keys.push({
-      pubkey: accounts.obligationFarmUserState,
-      isSigner: false,
-      isWritable: true
-    });
-  }
-  if (accounts.reserveFarmState) {
-    keys.push({
-      pubkey: accounts.reserveFarmState,
-      isSigner: false,
-      isWritable: true
+      name: "complete_withdrawal",
+      docs: [
+        "User claims their withdrawal from escrow.",
+        "Burns shares and transfers assets to user's wallet."
+      ],
+      discriminator: [
+        107,
+        98,
+        134,
+        131,
+        74,
+        120,
+        174,
+        121
+      ],
+      accounts: [
+        {
+          name: "user",
+          docs: [
+            "User claiming the withdrawal."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "LpVault (needed for shares_mint validation)."
+          ]
+        },
+        {
+          name: "assets_mint",
+          docs: [
+            "Mint of the vault assets."
+          ],
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Mint for vault shares."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "user_asset_ata",
+          docs: [
+            "User's asset token account (destination for claimed assets)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "assets_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: "withdraw_escrow",
+          docs: [
+            "User's withdraw escrow."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  101,
+                  115,
+                  99,
+                  114,
+                  111,
+                  119
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "escrow_assets_account",
+          docs: [
+            "Escrow's asset token account (source of assets)."
+          ],
+          writable: true,
+          relations: [
+            "withdraw_escrow"
+          ]
+        },
+        {
+          name: "escrow_shares_account",
+          docs: [
+            "Escrow's share token account (shares to burn)."
+          ],
+          writable: true,
+          relations: [
+            "withdraw_escrow"
+          ]
+        },
+        {
+          name: "withdraw_receipt",
+          docs: [
+            "User's withdraw receipt."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Token program."
+          ]
+        },
+        {
+          name: "associated_token_program",
+          docs: [
+            "Associated token program."
+          ],
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "deposit",
+      docs: [
+        "Deposit assets and receive shares instantly.",
+        "Requires NAV to be fresh (within nav_max_staleness)."
+      ],
+      discriminator: [
+        242,
+        35,
+        198,
+        137,
+        82,
+        225,
+        242,
+        182
+      ],
+      accounts: [
+        {
+          name: "user",
+          docs: [
+            "User depositing into the vault."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "LpVault to deposit into."
+          ],
+          writable: true,
+          relations: [
+            "withdrawal_policy"
+          ]
+        },
+        {
+          name: "withdrawal_policy",
+          docs: [
+            "Withdrawal policy for net capacity accounting. Deposits offset usage."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108,
+                  95,
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "assets_account",
+          docs: [
+            "Token account for vault assets."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "user_asset_ata",
+          docs: [
+            "User's asset token account (source of deposit)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "assets_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: "user_share_ata",
+          docs: [
+            "User's share token account (destination for minted shares)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "shares_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: "deposit_receipt",
+          docs: [
+            "Deposit receipt account",
+            "Derived from user pubkey and lp_vault pubkey."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "assets_mint",
+          docs: [
+            "Mint of the vault assets."
+          ],
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Mint for vault shares."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Token program."
+          ]
+        },
+        {
+          name: "associated_token_program",
+          docs: [
+            "Associated token program."
+          ],
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "fulfill_withdrawal",
+      docs: [
+        "Fulfill pending withdrawals by transferring assets to user's escrow.",
+        "Called by keeper when liquidity is available."
+      ],
+      discriminator: [
+        57,
+        37,
+        123,
+        221,
+        103,
+        93,
+        162,
+        176
+      ],
+      accounts: [
+        {
+          name: "signer",
+          docs: [
+            "Keeper signer. Must be the vault's fund_authority or keeper_authority."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "user"
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "LpVault."
+          ],
+          writable: true,
+          relations: [
+            "withdrawal_policy"
+          ]
+        },
+        {
+          name: "withdrawal_policy",
+          docs: [
+            "Withdrawal policy used to retain the configured base-asset fee."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108,
+                  95,
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "assets_account",
+          docs: [
+            "Vault's asset token account."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "assets_mint",
+          docs: [
+            "Mint of the vault assets."
+          ],
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Mint for vault shares."
+          ],
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "withdraw_escrow",
+          docs: [
+            "User's withdraw escrow."
+          ],
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  101,
+                  115,
+                  99,
+                  114,
+                  111,
+                  119
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "escrow_assets_account",
+          docs: [
+            "Escrow's asset token account (destination for assets)."
+          ],
+          writable: true,
+          relations: [
+            "withdraw_escrow"
+          ]
+        },
+        {
+          name: "withdraw_receipt",
+          docs: [
+            "User's withdraw receipt."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Token program."
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "init_global_config",
+      discriminator: [
+        140,
+        136,
+        214,
+        48,
+        87,
+        0,
+        120,
+        255
+      ],
+      accounts: [
+        {
+          name: "signer",
+          docs: [
+            "Signer initializing the GlobalConfig. MUST be the program's",
+            "BPFLoaderUpgradeable upgrade authority (proven by the constraints on",
+            "`program` + `program_data` below). Becomes the super_admin; the only",
+            "later rotation path is `update_admin_authorities`, which is likewise",
+            "gated on the upgrade authority. On a fresh deploy, call init BEFORE",
+            "finalizing the program (a finalized/`--final` program has no upgrade",
+            "authority \u2192 init AND rotation impossible) and while a plain deployer",
+            "keypair (not a multisig PDA) still holds it."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "global_config",
+          docs: [
+            "Global config account. Derived with a single str."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program",
+          docs: [
+            "This program's own account; ties `program_data` to this program so the",
+            "upgrade-authority check below cannot be satisfied with an unrelated",
+            "program's ProgramData."
+          ],
+          address: "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV"
+        },
+        {
+          name: "program_data",
+          docs: [
+            "ProgramData account holding the program's upgrade authority. Gate: the",
+            "signer must equal the upgrade authority. `programdata_address()` returns",
+            "`Ok(None)` for a non-upgradeable load and a revoked authority is `None`,",
+            "so a `None` on either side fails closed."
+          ]
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "create_authority",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "init_lp_vault",
+      discriminator: [
+        40,
+        247,
+        24,
+        8,
+        152,
+        98,
+        18,
+        220
+      ],
+      accounts: [
+        {
+          name: "signer",
+          docs: [
+            "User creating the vault."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "Lp vault being created."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "arg",
+                path: "vault_name"
+              },
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "assets_mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "global_config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Mint for shares, minted on deposit."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  104,
+                  97,
+                  114,
+                  101,
+                  115
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "assets_mint",
+          docs: [
+            "Mint of the assets, USDC, maybe configurable."
+          ]
+        },
+        {
+          name: "assets_account",
+          docs: [
+            "Token account for main asset."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  109,
+                  97,
+                  105,
+                  110,
+                  95,
+                  97,
+                  115,
+                  115,
+                  101,
+                  116,
+                  115
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "pending_shares_account",
+          docs: [
+            "Token account where shares are held during queued (illiquid) withdrawals."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  101,
+                  110,
+                  100,
+                  105,
+                  110,
+                  103,
+                  95,
+                  115,
+                  104,
+                  97,
+                  114,
+                  101,
+                  115
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "withdrawal_policy",
+          docs: [
+            "Withdrawal policy PDA for retained fees and net outflow caps."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108,
+                  95,
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "fee_recipient_account",
+          docs: [
+            "Optional fee recipient token account (shares mint).",
+            "Required when initializing with performance_fee_bps > 0."
+          ],
+          optional: true
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Can either be spl-token or token-2022."
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "fund_authority",
+          type: "pubkey"
+        },
+        {
+          name: "nav_max_staleness",
+          type: "u64"
+        },
+        {
+          name: "vault_name",
+          type: "string"
+        },
+        {
+          name: "decimals",
+          type: "u8"
+        },
+        {
+          name: "performance_fee_bps",
+          type: "u16"
+        },
+        {
+          name: "assessment_interval_secs",
+          type: "i64"
+        },
+        {
+          name: "keeper_authority",
+          type: {
+            option: "pubkey"
+          }
+        }
+      ]
+    },
+    {
+      name: "set_fee_config",
+      docs: [
+        "Configure or disable performance fee settings."
+      ],
+      discriminator: [
+        221,
+        222,
+        52,
+        206,
+        114,
+        198,
+        64,
+        91
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Operator / fund authority."
+          ],
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault",
+          writable: true
+        },
+        {
+          name: "shares_mint",
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "fee_recipient_account",
+          docs: [
+            "Token account that will receive fee shares.",
+            "Required when enabling fees (performance_fee_bps > 0) or when",
+            "mid-window settlement is needed (accrued fees must be settled",
+            "to the old recipient before changing config).",
+            "Omit when disabling with no accrued fees.",
+            "Mutable because it may be the destination of a MintTo CPI during mid-window settlement."
+          ],
+          writable: true,
+          optional: true
+        },
+        {
+          name: "token_program"
+        }
+      ],
+      args: [
+        {
+          name: "performance_fee_bps",
+          type: "u16"
+        },
+        {
+          name: "assessment_interval_secs",
+          type: "i64"
+        }
+      ]
+    },
+    {
+      name: "set_keeper_authority",
+      docs: [
+        "Set or remove the keeper authority on a vault.",
+        "When set, this key can call fulfill_withdrawal in addition to fund_authority."
+      ],
+      discriminator: [
+        29,
+        124,
+        191,
+        114,
+        184,
+        243,
+        33,
+        155
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Fund authority \u2014 only they can change keeper authority."
+          ],
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "payer",
+          docs: [
+            "Payer for any reallocation rent."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          writable: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "keeper_authority",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_metadata",
+      discriminator: [
+        78,
+        157,
+        75,
+        242,
+        151,
+        20,
+        121,
+        144
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Fund authority - only they can set metadata."
+          ],
+          writable: true,
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "LpVault that owns the shares_mint."
+          ]
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Shares mint for which we're setting metadata."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "metadata_account",
+          docs: [
+            'Seeds: ["metadata", token_metadata_program_id, mint]'
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  109,
+                  101,
+                  116,
+                  97,
+                  100,
+                  97,
+                  116,
+                  97
+                ]
+              },
+              {
+                kind: "const",
+                value: [
+                  11,
+                  112,
+                  101,
+                  177,
+                  227,
+                  209,
+                  124,
+                  69,
+                  56,
+                  157,
+                  82,
+                  127,
+                  107,
+                  4,
+                  195,
+                  205,
+                  88,
+                  184,
+                  108,
+                  115,
+                  26,
+                  160,
+                  253,
+                  181,
+                  73,
+                  182,
+                  209,
+                  188,
+                  3,
+                  248,
+                  41,
+                  70
+                ]
+              },
+              {
+                kind: "account",
+                path: "shares_mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                11,
+                112,
+                101,
+                177,
+                227,
+                209,
+                124,
+                69,
+                56,
+                157,
+                82,
+                127,
+                107,
+                4,
+                195,
+                205,
+                88,
+                184,
+                108,
+                115,
+                26,
+                160,
+                253,
+                181,
+                73,
+                182,
+                209,
+                188,
+                3,
+                248,
+                41,
+                70
+              ]
+            }
+          }
+        },
+        {
+          name: "token_metadata_program",
+          address: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "rent",
+          docs: [
+            "Rent sysvar."
+          ],
+          address: "SysvarRent111111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "symbol",
+          type: "string"
+        },
+        {
+          name: "uri",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "set_withdrawal_policy",
+      docs: [
+        "Configure retained withdrawal fees and net withdrawal caps."
+      ],
+      discriminator: [
+        3,
+        223,
+        67,
+        81,
+        69,
+        30,
+        203,
+        150
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Fund authority for the vault."
+          ],
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "payer",
+          docs: [
+            "Payer for creating the policy account on existing vaults."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault"
+        },
+        {
+          name: "withdrawal_policy",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108,
+                  95,
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "withdrawal_fee_bps",
+          type: "u16"
+        },
+        {
+          name: "hourly_withdrawal_cap_bps",
+          type: "u16"
+        },
+        {
+          name: "daily_withdrawal_cap_bps",
+          type: "u16"
+        }
+      ]
+    },
+    {
+      name: "update_admin_authorities",
+      docs: [
+        "Rotate super_admin, create_authority, and permissioned_creation",
+        "atomically. Recovery instruction gated on the program's",
+        "BPFLoaderUpgradeable upgrade authority (NOT the current super_admin),",
+        "so a compromised or lost super_admin can be replaced."
+      ],
+      discriminator: [
+        41,
+        241,
+        142,
+        184,
+        75,
+        212,
+        72,
+        171
+      ],
+      accounts: [
+        {
+          name: "signer",
+          docs: [
+            "Signer rotating the authorities. MUST be the program's",
+            "BPFLoaderUpgradeable upgrade authority (proven by the constraints on",
+            "`program` + `program_data` below)."
+          ],
+          signer: true
+        },
+        {
+          name: "global_config",
+          docs: [
+            "The global config account being rotated. Unique in the program.",
+            "Deliberately no `has_one = super_admin`: see the struct docs."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program",
+          docs: [
+            "This program's own account; ties `program_data` to this program so the",
+            "upgrade-authority check below cannot be satisfied with an unrelated",
+            "program's ProgramData."
+          ],
+          address: "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV"
+        },
+        {
+          name: "program_data",
+          docs: [
+            "ProgramData account holding the program's upgrade authority. Gate: the",
+            "signer must equal the upgrade authority. `programdata_address()` returns",
+            "`Ok(None)` for a non-upgradeable load and a revoked authority is `None`,",
+            "so a `None` on either side fails closed."
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "new_super_admin",
+          type: "pubkey"
+        },
+        {
+          name: "new_create_authority",
+          type: "pubkey"
+        },
+        {
+          name: "new_permissioned_creation",
+          type: "bool"
+        }
+      ]
+    },
+    {
+      name: "update_global_config",
+      discriminator: [
+        164,
+        84,
+        130,
+        189,
+        111,
+        58,
+        250,
+        200
+      ],
+      accounts: [
+        {
+          name: "super_admin",
+          docs: [
+            "The signer must be the global_config super_admin."
+          ],
+          writable: true,
+          signer: true,
+          relations: [
+            "global_config"
+          ]
+        },
+        {
+          name: "global_config",
+          docs: [
+            "The global config account. Unique in the program."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_create_authority",
+          type: "pubkey"
+        },
+        {
+          name: "is_creation_permissioned",
+          type: "bool"
+        }
+      ]
+    },
+    {
+      name: "update_nav",
+      docs: [
+        "Update the vault's NAV. Called by fund_authority (operator)."
+      ],
+      discriminator: [
+        56,
+        16,
+        234,
+        109,
+        155,
+        165,
+        5,
+        0
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Fund authority - only they can update NAV."
+          ],
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault",
+          writable: true
+        },
+        {
+          name: "shares_mint",
+          relations: [
+            "lp_vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "new_nav",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "update_nav_max_staleness",
+      docs: [
+        "Update the NAV max staleness window on a vault."
+      ],
+      discriminator: [
+        212,
+        225,
+        120,
+        109,
+        83,
+        96,
+        40,
+        17
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          docs: [
+            "Fund authority \u2014 only they can change vault config."
+          ],
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault",
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "nav_max_staleness",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "withdraw",
+      docs: [
+        "Withdraw shares for assets.",
+        "If vault has sufficient liquidity: instant withdrawal.",
+        "If illiquid: creates WithdrawReceipt, shares go to pending account."
+      ],
+      discriminator: [
+        183,
+        18,
+        70,
+        156,
+        148,
+        109,
+        161,
+        34
+      ],
+      accounts: [
+        {
+          name: "user",
+          docs: [
+            "User withdrawing from the vault."
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "lp_vault",
+          docs: [
+            "LpVault to withdraw from."
+          ],
+          writable: true,
+          relations: [
+            "withdrawal_policy"
+          ]
+        },
+        {
+          name: "withdrawal_policy",
+          docs: [
+            "Withdrawal policy for retained asset fees and net withdrawal caps."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108,
+                  95,
+                  112,
+                  111,
+                  108,
+                  105,
+                  99,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "assets_account",
+          docs: [
+            "Token account for vault assets."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "user_share_ata",
+          docs: [
+            "User's share token account (source of shares)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "shares_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: "assets_mint",
+          docs: [
+            "Mint of the vault assets."
+          ],
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "shares_mint",
+          docs: [
+            "Mint for vault shares (mutable for fee mint CPI)."
+          ],
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "fee_recipient_account",
+          docs: [
+            "Token account that receives fee shares on withdrawal.",
+            "Required when `has_fee_config()` is true; omit otherwise.",
+            "Mutable because it is the destination of a MintTo CPI."
+          ],
+          writable: true,
+          optional: true
+        },
+        {
+          name: "withdraw_escrow",
+          docs: [
+            "Withdraw escrow - holds assets and shares until user claims."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  101,
+                  115,
+                  99,
+                  114,
+                  111,
+                  119
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "escrow_assets_account",
+          docs: [
+            "Escrow's asset token account (holds USDC for user to claim)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "withdraw_escrow"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "assets_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: "escrow_shares_account",
+          docs: [
+            "Escrow's share token account (holds shares until burned on claim)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "withdraw_escrow"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "shares_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: "withdraw_receipt",
+          docs: [
+            "Withdraw receipt - tracks pending and claimable amounts (accumulates)."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  95,
+                  114,
+                  101,
+                  99,
+                  101,
+                  105,
+                  112,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "lp_vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          docs: [
+            "System program."
+          ],
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Token program."
+          ]
+        },
+        {
+          name: "associated_token_program",
+          docs: [
+            "Associated token program."
+          ],
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: [
+        {
+          name: "shares_amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "withdraw_assets",
+      docs: [
+        "Withdraw assets from vault to operator wallet for investment."
+      ],
+      discriminator: [
+        202,
+        105,
+        54,
+        155,
+        56,
+        33,
+        207,
+        254
+      ],
+      accounts: [
+        {
+          name: "fund_authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "lp_vault"
+        },
+        {
+          name: "assets_account",
+          writable: true,
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "authority_asset_ata",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "fund_authority"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "assets_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: "assets_mint",
+          relations: [
+            "lp_vault"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "DepositReceipt",
+      discriminator: [
+        64,
+        175,
+        24,
+        183,
+        138,
+        109,
+        70,
+        78
+      ]
+    },
+    {
+      name: "GlobalConfig",
+      discriminator: [
+        149,
+        8,
+        156,
+        202,
+        160,
+        252,
+        176,
+        217
+      ]
+    },
+    {
+      name: "LpVault",
+      discriminator: [
+        189,
+        45,
+        167,
+        23,
+        91,
+        118,
+        105,
+        190
+      ]
+    },
+    {
+      name: "WithdrawEscrow",
+      discriminator: [
+        161,
+        63,
+        221,
+        55,
+        116,
+        204,
+        131,
+        11
+      ]
+    },
+    {
+      name: "WithdrawReceipt",
+      discriminator: [
+        132,
+        238,
+        44,
+        182,
+        207,
+        9,
+        124,
+        140
+      ]
+    },
+    {
+      name: "WithdrawalPolicy",
+      discriminator: [
+        52,
+        231,
+        68,
+        59,
+        247,
+        250,
+        119,
+        244
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AdminAuthoritiesUpdated",
+      discriminator: [
+        1,
+        164,
+        87,
+        62,
+        157,
+        85,
+        1,
+        113
+      ]
+    },
+    {
+      name: "FeeConfigUpdated",
+      discriminator: [
+        45,
+        50,
+        42,
+        173,
+        193,
+        67,
+        52,
+        244
+      ]
+    },
+    {
+      name: "FeesAssessed",
+      discriminator: [
+        210,
+        177,
+        59,
+        191,
+        116,
+        251,
+        25,
+        131
+      ]
+    },
+    {
+      name: "WithdrawalFeeRetained",
+      discriminator: [
+        105,
+        104,
+        190,
+        198,
+        168,
+        231,
+        18,
+        182
+      ]
+    },
+    {
+      name: "WithdrawalFeesSettled",
+      discriminator: [
+        106,
+        253,
+        199,
+        177,
+        101,
+        104,
+        38,
+        219
+      ]
+    },
+    {
+      name: "WithdrawalPolicyUpdated",
+      discriminator: [
+        252,
+        196,
+        144,
+        224,
+        210,
+        3,
+        71,
+        66
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "ArithmeticError",
+      msg: "Arithmetic error!"
+    },
+    {
+      code: 6001,
+      name: "ObsoleteVaultData",
+      msg: "LpVault data is outdated!"
+    },
+    {
+      code: 6002,
+      name: "StaleNav",
+      msg: "NAV is stale - operator must update NAV before this operation!"
+    },
+    {
+      code: 6003,
+      name: "Unauthorized",
+      msg: "Signer is not an authority!"
+    },
+    {
+      code: 6004,
+      name: "InvalidMint",
+      msg: "Invalid mint extension!"
+    },
+    {
+      code: 6005,
+      name: "NameTooLong",
+      msg: "LP Vault name is too long!"
+    },
+    {
+      code: 6006,
+      name: "BlockedDeposit",
+      msg: "Deposits are blocked - NAV is zero!"
+    },
+    {
+      code: 6007,
+      name: "InsufficientLiquidity",
+      msg: "Insufficient liquid assets for instant withdrawal!"
+    },
+    {
+      code: 6008,
+      name: "InvalidShareAmount",
+      msg: "Invalid share amount!"
+    },
+    {
+      code: 6009,
+      name: "InvalidDepositAmount",
+      msg: "Invalid deposit amount!"
+    },
+    {
+      code: 6010,
+      name: "NoPendingWithdrawal",
+      msg: "No pending withdrawal to fulfill!"
+    },
+    {
+      code: 6011,
+      name: "NoClaimableAssets",
+      msg: "No claimable assets to withdraw!"
+    },
+    {
+      code: 6012,
+      name: "FeeRecipientNotConfigured",
+      msg: "Fee recipient is not configured!"
+    },
+    {
+      code: 6013,
+      name: "InvalidPerformanceFeeBps",
+      msg: "Invalid performance fee - must be <= MAX_PERFORMANCE_FEE_BPS!"
+    },
+    {
+      code: 6014,
+      name: "InvalidFeeRecipient",
+      msg: "Invalid fee recipient account!"
+    },
+    {
+      code: 6015,
+      name: "AssessmentTooEarly",
+      msg: "Assessment interval has not elapsed!"
+    },
+    {
+      code: 6016,
+      name: "InvalidAssessmentInterval",
+      msg: "Invalid assessment interval!"
+    },
+    {
+      code: 6017,
+      name: "NavUpdateTooLarge",
+      msg: "NAV update would change share price by more than the allowed maximum!"
+    },
+    {
+      code: 6018,
+      name: "InvalidWithdrawalFeeBps",
+      msg: "Invalid withdrawal fee - must be <= MAX_WITHDRAWAL_FEE_BPS!"
+    },
+    {
+      code: 6019,
+      name: "InvalidWithdrawalCapBps",
+      msg: "Invalid withdrawal cap - must be <= 10000 bps!"
+    },
+    {
+      code: 6020,
+      name: "HourlyWithdrawalCapExceeded",
+      msg: "Withdrawal exceeds hourly vault capacity!"
+    },
+    {
+      code: 6021,
+      name: "DailyWithdrawalCapExceeded",
+      msg: "Withdrawal exceeds daily vault capacity!"
+    },
+    {
+      code: 6022,
+      name: "InvalidWithdrawalPolicy",
+      msg: "Invalid withdrawal policy account!"
+    },
+    {
+      code: 6023,
+      name: "InvalidAuthority",
+      msg: "New authority cannot be the default (all-zeros) pubkey!"
+    }
+  ],
+  types: [
+    {
+      name: "AdminAuthoritiesUpdated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_super_admin",
+            type: "pubkey"
+          },
+          {
+            name: "new_super_admin",
+            type: "pubkey"
+          },
+          {
+            name: "old_create_authority",
+            type: "pubkey"
+          },
+          {
+            name: "new_create_authority",
+            type: "pubkey"
+          },
+          {
+            name: "old_permissioned_creation",
+            type: "bool"
+          },
+          {
+            name: "new_permissioned_creation",
+            type: "bool"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositReceipt",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "bump",
+            docs: [
+              "PDA bump seed."
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "FeeConfigUpdated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "old_fee_recipient",
+            type: "pubkey"
+          },
+          {
+            name: "new_fee_recipient",
+            type: "pubkey"
+          },
+          {
+            name: "old_fee_bps",
+            type: "u16"
+          },
+          {
+            name: "new_fee_bps",
+            type: "u16"
+          },
+          {
+            name: "assessment_interval_secs",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "FeesAssessed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "profit_assets",
+            type: "u64"
+          },
+          {
+            name: "fee_assets",
+            type: "u64"
+          },
+          {
+            name: "fee_shares_minted",
+            type: "u64"
+          },
+          {
+            name: "new_pps",
+            type: "u64"
+          },
+          {
+            name: "checkpoint_pps",
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "GlobalConfig",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "super_admin",
+            docs: [
+              "Key with the ability to update the GlobalConfig. Rotatable only via",
+              "`update_admin_authorities` (gated on the program upgrade authority)."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "permissioned_creation",
+            docs: [
+              "When true InitializeLpVault requires create_authority to be a signer"
+            ],
+            type: "bool"
+          },
+          {
+            name: "create_authority",
+            docs: [
+              "The key with authority to call `InitializeLpVault`"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump for increased efficiency."
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "LpVault",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "assets_account",
+            docs: [
+              "USDC TokenAccount where users deposit, funds agent operations."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "pending_shares_account",
+            docs: [
+              "TokenAccount where shares are held during queued (illiquid) withdrawals."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "shares_mint",
+            docs: [
+              "Derived mint (created on initialize) that represents LP tokens or shares."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "assets_mint",
+            docs: [
+              "Mint corresponding to the asset, most of the time USDC."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "fund_authority",
+            docs: [
+              "Pubkey authorized to withdraw assets from assets_account and update NAV."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "nav",
+            docs: [
+              "Current Net Asset Value (total vault value in asset decimals)."
+            ],
+            type: "u64"
+          },
+          {
+            name: "total_shares",
+            docs: [
+              "Total shares outstanding (cached for efficiency). May temporarily diverge",
+              "from shares_mint.supply during the escrow withdrawal flow (between",
+              "fulfill_withdrawal and complete_withdrawal)."
+            ],
+            type: "u64"
+          },
+          {
+            name: "nav_updated_at",
+            docs: [
+              "Timestamp for when NAV was last updated."
+            ],
+            type: "i64"
+          },
+          {
+            name: "nav_max_staleness",
+            docs: [
+              "Maximum NAV staleness for user operations (in seconds).",
+              "Deposits and withdrawals fail if NAV is older than this."
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA derivation bump, stored for CU saving purposes."
+            ],
+            type: "u8"
+          },
+          {
+            name: "vault_name",
+            type: "string"
+          },
+          {
+            name: "pending_withdrawal_value",
+            docs: [
+              "Total value of pending withdrawals awaiting liquidity.",
+              "When a withdrawal cannot be fulfilled instantly due to insufficient",
+              "liquid assets, the value is tracked here. This is approximate \u2014 the",
+              "value recorded at withdrawal time may differ from the value at",
+              "fulfillment time (recomputed at current NAV). Used for operator",
+              "visibility only, not for critical calculations."
+            ],
+            type: "u64"
+          },
+          {
+            name: "fee_recipient",
+            docs: [
+              "Shares token account that receives fee shares. Pubkey::default() = disabled."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "performance_fee_bps",
+            docs: [
+              "Performance fee rate in basis points (2000 = 20%). 0 = disabled."
+            ],
+            type: "u16"
+          },
+          {
+            name: "assessment_interval_secs",
+            docs: [
+              "How often scheduled fees are assessed (seconds). E.g., 86400 = 24h."
+            ],
+            type: "i64"
+          },
+          {
+            name: "last_assessment_timestamp",
+            docs: [
+              "Unix timestamp of last fee event (scheduled or withdrawal-triggered)."
+            ],
+            type: "i64"
+          },
+          {
+            name: "price_per_share_at_last_assessment",
+            docs: [
+              "PPS at last fee event, scaled by PRICE_SCALE. High-water mark for fees."
+            ],
+            type: "u64"
+          },
+          {
+            name: "keeper_authority",
+            docs: [
+              "Optional keeper authority. When set (non-default), this key can call",
+              "fulfill_withdrawal in addition to fund_authority. Allows the keeper",
+              "process to use a separate key from the agent/fund_authority.",
+              "Pubkey::default() = not set (only fund_authority can fulfill)."
+            ],
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawEscrow",
+      docs: [
+        "Escrow account that holds assets and shares for a pending withdrawal.",
+        "Each user has one escrow per vault, derived as PDA from [WITHDRAW_ESCROW_SEED, user, vault]."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            docs: [
+              "User who owns this escrow."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "lp_vault",
+            docs: [
+              "The vault this escrow is associated with."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "escrow_assets_account",
+            docs: [
+              "Token account holding escrowed assets (USDC)."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "escrow_shares_account",
+            docs: [
+              "Token account holding escrowed shares (for burning on claim)."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA derivation bump."
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawReceipt",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            docs: [
+              "User requesting withdrawal."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "lp_vault",
+            docs: [
+              "Vault where the user has invested."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "pending_shares",
+            docs: [
+              "Shares waiting for liquidity (keeper needs to fulfill these).",
+              "These shares are held in the escrow_shares_account."
+            ],
+            type: "u64"
+          },
+          {
+            name: "claimable_shares",
+            docs: [
+              "Shares that have been fulfilled and are ready to claim.",
+              "These shares are also in escrow_shares_account, waiting to be burned on claim."
+            ],
+            type: "u64"
+          },
+          {
+            name: "claimable_assets",
+            docs: [
+              "Asset value ready to claim (held in escrow_assets_account)."
+            ],
+            type: "u64"
+          },
+          {
+            name: "oldest_pending_at",
+            docs: [
+              "Timestamp of the earliest pending withdrawal (for NAV staleness checks)."
+            ],
+            type: "i64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA derivation bump, stored for CU saving purposes."
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalFeeRetained",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "gross_assets",
+            type: "u64"
+          },
+          {
+            name: "fee_assets",
+            type: "u64"
+          },
+          {
+            name: "net_assets",
+            type: "u64"
+          },
+          {
+            name: "withdrawal_fee_bps",
+            type: "u16"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalFeesSettled",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "shares_withdrawn",
+            type: "u64"
+          },
+          {
+            name: "asset_value",
+            type: "u64"
+          },
+          {
+            name: "fee_shares_minted",
+            type: "u64"
+          },
+          {
+            name: "proration_elapsed",
+            type: "i64"
+          },
+          {
+            name: "proration_interval",
+            type: "i64"
+          },
+          {
+            name: "pps_after_fees",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalPolicy",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "lp_vault",
+            docs: [
+              "Vault this policy belongs to."
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "withdrawal_fee_bps",
+            docs: [
+              "Base-asset fee retained in the vault on withdrawal. 30 = 0.30%."
+            ],
+            type: "u16"
+          },
+          {
+            name: "hourly_withdrawal_cap_bps",
+            docs: [
+              "Max net withdrawal accepted per hour as bps of current NAV. 0 = disabled."
+            ],
+            type: "u16"
+          },
+          {
+            name: "daily_withdrawal_cap_bps",
+            docs: [
+              "Max net withdrawal accepted per day as bps of current NAV. 0 = disabled."
+            ],
+            type: "u16"
+          },
+          {
+            name: "hourly_withdrawn_assets",
+            docs: [
+              "Net withdrawn assets counted in the current hourly window."
+            ],
+            type: "u64"
+          },
+          {
+            name: "daily_withdrawn_assets",
+            docs: [
+              "Net withdrawn assets counted in the current daily window."
+            ],
+            type: "u64"
+          },
+          {
+            name: "hourly_window_start",
+            docs: [
+              "Start timestamp for the current hourly cap window."
+            ],
+            type: "i64"
+          },
+          {
+            name: "daily_window_start",
+            docs: [
+              "Start timestamp for the current daily cap window."
+            ],
+            type: "i64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA derivation bump."
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalPolicyUpdated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "withdrawal_fee_bps",
+            type: "u16"
+          },
+          {
+            name: "hourly_withdrawal_cap_bps",
+            type: "u16"
+          },
+          {
+            name: "daily_withdrawal_cap_bps",
+            type: "u16"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/vendor/gamma/idl/index.ts
+var GAMMA_VAULT_IDL = gamma_vault_default;
+function deriveGammaWithdrawalPolicy(lpVault, programId = GAMMA_VAULT_PROGRAM_ID) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_WITHDRAWAL_POLICY), lpVault.toBuffer()],
+    programId
+  );
+}
+function deriveGammaDepositReceipt(user, lpVault, programId = GAMMA_VAULT_PROGRAM_ID) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_DEPOSIT_RECEIPT), user.toBuffer(), lpVault.toBuffer()],
+    programId
+  );
+}
+function deriveGammaWithdrawEscrow(user, lpVault, programId = GAMMA_VAULT_PROGRAM_ID) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_WITHDRAW_ESCROW), user.toBuffer(), lpVault.toBuffer()],
+    programId
+  );
+}
+function deriveGammaWithdrawReceipt(user, lpVault, programId = GAMMA_VAULT_PROGRAM_ID) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_WITHDRAW_RECEIPT), user.toBuffer(), lpVault.toBuffer()],
+    programId
+  );
+}
+function deriveGammaAta(mint, owner, tokenProgram = TOKEN_PROGRAM_ID) {
+  return getAssociatedTokenAddressSync(
+    mint,
+    owner,
+    true,
+    tokenProgram,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+}
+var GAMMA_ACCOUNTS_CODER = new anchor.BorshAccountsCoder(GAMMA_VAULT_IDL);
+var lpVaultDiscriminator = Buffer.from([189, 45, 167, 23, 91, 118, 105, 190]);
+var withdrawReceiptDiscriminator = Buffer.from([132, 238, 44, 182, 207, 9, 124, 140]);
+var toBN = (v) => BN9__default.default.isBN(v) ? v : new BN9__default.default((v ?? 0).toString());
+function decodeGammaLpVaultData(data, pubkey) {
+  if (!data.subarray(0, 8).equals(lpVaultDiscriminator)) {
+    throw new Error("invalid Gamma LpVault account discriminator");
+  }
+  const d = GAMMA_ACCOUNTS_CODER.decode("LpVault", data);
+  return {
+    pubkey,
+    assetsAccount: d.assets_account ?? d.assetsAccount,
+    pendingSharesAccount: d.pending_shares_account ?? d.pendingSharesAccount,
+    sharesMint: d.shares_mint ?? d.sharesMint,
+    assetsMint: d.assets_mint ?? d.assetsMint,
+    fundAuthority: d.fund_authority ?? d.fundAuthority,
+    nav: toBN(d.nav),
+    totalShares: toBN(d.total_shares ?? d.totalShares),
+    navUpdatedAt: toBN(d.nav_updated_at ?? d.navUpdatedAt),
+    navMaxStaleness: toBN(d.nav_max_staleness ?? d.navMaxStaleness),
+    bump: d.bump,
+    vaultName: d.vault_name ?? d.vaultName,
+    pendingWithdrawalValue: toBN(d.pending_withdrawal_value ?? d.pendingWithdrawalValue),
+    feeRecipient: d.fee_recipient ?? d.feeRecipient,
+    performanceFeeBps: d.performance_fee_bps ?? d.performanceFeeBps,
+    assessmentIntervalSecs: toBN(d.assessment_interval_secs ?? d.assessmentIntervalSecs),
+    lastAssessmentTimestamp: toBN(d.last_assessment_timestamp ?? d.lastAssessmentTimestamp),
+    pricePerShareAtLastAssessment: toBN(
+      d.price_per_share_at_last_assessment ?? d.pricePerShareAtLastAssessment
+    ),
+    keeperAuthority: d.keeper_authority ?? d.keeperAuthority
+  };
+}
+function decodeGammaWithdrawReceiptData(data, pubkey) {
+  if (!data.subarray(0, 8).equals(withdrawReceiptDiscriminator)) {
+    throw new Error("invalid Gamma WithdrawReceipt account discriminator");
+  }
+  const d = GAMMA_ACCOUNTS_CODER.decode("WithdrawReceipt", data);
+  return {
+    pubkey,
+    user: d.user,
+    lpVault: d.lp_vault ?? d.lpVault,
+    pendingShares: toBN(d.pending_shares ?? d.pendingShares),
+    claimableShares: toBN(d.claimable_shares ?? d.claimableShares),
+    claimableAssets: toBN(d.claimable_assets ?? d.claimableAssets),
+    oldestPendingAt: toBN(d.oldest_pending_at ?? d.oldestPendingAt),
+    bump: d.bump
+  };
+}
+var DEPOSIT_DISCRIMINATOR = Buffer.from([242, 35, 198, 137, 82, 225, 242, 182]);
+var WITHDRAW_DISCRIMINATOR = Buffer.from([183, 18, 70, 156, 148, 109, 161, 34]);
+var COMPLETE_WITHDRAWAL_DISCRIMINATOR = Buffer.from([107, 98, 134, 131, 74, 120, 174, 121]);
+var encodeU64 = (amount) => amount.toArrayLike(Buffer, "le", 8);
+var meta = (pubkey, isSigner, isWritable) => ({
+  pubkey,
+  isSigner,
+  isWritable
+});
+function makeGammaDepositIx(accounts, amount) {
+  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const associatedTokenProgram = accounts.associatedTokenProgram ?? ASSOCIATED_TOKEN_PROGRAM_ID;
+  const keys = [
+    meta(accounts.user, true, true),
+    meta(accounts.lpVault, false, true),
+    meta(accounts.withdrawalPolicy, false, true),
+    meta(accounts.assetsAccount, false, true),
+    meta(accounts.userAssetAta, false, true),
+    meta(accounts.userShareAta, false, true),
+    meta(accounts.depositReceipt, false, true),
+    meta(accounts.assetsMint, false, false),
+    meta(accounts.sharesMint, false, true),
+    meta(web3_js.SystemProgram.programId, false, false),
+    meta(tokenProgram, false, false),
+    meta(associatedTokenProgram, false, false)
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: GAMMA_VAULT_PROGRAM_ID,
+    data: Buffer.concat([DEPOSIT_DISCRIMINATOR, encodeU64(amount)])
+  });
+}
+function makeGammaWithdrawIx(accounts, sharesAmount) {
+  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const associatedTokenProgram = accounts.associatedTokenProgram ?? ASSOCIATED_TOKEN_PROGRAM_ID;
+  const keys = [
+    meta(accounts.user, true, true),
+    meta(accounts.lpVault, false, true),
+    meta(accounts.withdrawalPolicy, false, true),
+    meta(accounts.assetsAccount, false, true),
+    meta(accounts.userShareAta, false, true),
+    meta(accounts.assetsMint, false, false),
+    meta(accounts.sharesMint, false, true),
+    meta(accounts.feeRecipientAccount, false, true),
+    meta(accounts.withdrawEscrow, false, true),
+    meta(accounts.escrowAssetsAccount, false, true),
+    meta(accounts.escrowSharesAccount, false, true),
+    meta(accounts.withdrawReceipt, false, true),
+    meta(web3_js.SystemProgram.programId, false, false),
+    meta(tokenProgram, false, false),
+    meta(associatedTokenProgram, false, false)
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: GAMMA_VAULT_PROGRAM_ID,
+    data: Buffer.concat([WITHDRAW_DISCRIMINATOR, encodeU64(sharesAmount)])
+  });
+}
+function makeGammaCompleteWithdrawalIx(accounts) {
+  const tokenProgram = accounts.tokenProgram ?? TOKEN_PROGRAM_ID;
+  const associatedTokenProgram = accounts.associatedTokenProgram ?? ASSOCIATED_TOKEN_PROGRAM_ID;
+  const keys = [
+    meta(accounts.user, true, true),
+    meta(accounts.lpVault, false, false),
+    meta(accounts.assetsMint, false, false),
+    meta(accounts.sharesMint, false, true),
+    meta(accounts.userAssetAta, false, true),
+    meta(accounts.withdrawEscrow, false, true),
+    meta(accounts.escrowAssetsAccount, false, true),
+    meta(accounts.escrowSharesAccount, false, true),
+    meta(accounts.withdrawReceipt, false, true),
+    meta(web3_js.SystemProgram.programId, false, false),
+    meta(tokenProgram, false, false),
+    meta(associatedTokenProgram, false, false)
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: GAMMA_VAULT_PROGRAM_ID,
+    data: COMPLETE_WITHDRAWAL_DISCRIMINATOR
+  });
+}
+
+// src/vendor/klend/utils/klend/interest-rate.utils.ts
+function getKaminoTotalSupply(reserve) {
+  const liquidityAvailableAmount = new Decimal3__default.default(reserve.liquidity.availableAmount.toString());
+  const borrowedAmount = new Fraction(reserve.liquidity.borrowedAmountSf).toDecimal();
+  const accumulatedProtocolFee = new Fraction(
+    reserve.liquidity.accumulatedProtocolFeesSf
+  ).toDecimal();
+  const accumulatedReferrerFees = new Fraction(
+    reserve.liquidity.accumulatedReferrerFeesSf
+  ).toDecimal();
+  const pendingReferrerFees = new Fraction(reserve.liquidity.pendingReferrerFeesSf).toDecimal();
+  return liquidityAvailableAmount.add(borrowedAmount).sub(accumulatedProtocolFee).sub(accumulatedReferrerFees).sub(pendingReferrerFees);
+}
+function scaledSupplies(state) {
+  const liqMintDecimals = new Decimal3__default.default(state.liquidity.mintDecimals.toString());
+  const totalSupplyLamports = getKaminoTotalSupply(state);
+  const mintTotalSupplyLam = new Decimal3__default.default(state.collateral.mintTotalSupply.toString());
+  const liqScale = new Decimal3__default.default(10).pow(liqMintDecimals);
+  const collScale = new Decimal3__default.default(10).pow(liqMintDecimals);
+  const totalSupply = totalSupplyLamports.div(liqScale);
+  const totalCollateral = mintTotalSupplyLam.div(collScale);
+  return [totalSupply, totalCollateral];
+}
+
+// src/vendor/klend/utils/farms/serialize.utils.ts
+function kaminoFarmStateToDto(farmState) {
+  return {
+    token: {
+      mint: farmState.token.mint.toBase58(),
+      decimals: farmState.token.decimals.toString()
+    },
+    rewardInfos: farmState.rewardInfos.map((item) => ({
+      token: {
+        mint: item.token.mint.toBase58(),
+        decimals: item.token.decimals.toString()
+      },
+      rewardsAvailable: item.rewardsAvailable.toString(),
+      rewardsPerSecondDecimals: item.rewardsPerSecondDecimals,
+      rewardScheduleCurve: {
+        points: item.rewardScheduleCurve.points.map((p) => ({
+          tsStart: p.tsStart.toString(),
+          rewardPerTimeUnit: p.rewardPerTimeUnit.toString()
+        }))
+      }
+    }))
+  };
+}
+var farmDiscriminator = Buffer.from([198, 102, 216, 74, 63, 66, 163, 190]);
+var farmLayout = borsh.struct([
+  borsh.publicKey("farmAdmin"),
+  borsh.publicKey("globalConfig"),
+  borsh.struct(
+    [
+      borsh.publicKey("mint"),
+      borsh.u64("decimals"),
+      borsh.publicKey("tokenProgram"),
+      borsh.array(borsh.u64(), 6, "padding")
+    ],
+    "token"
+  ),
+  borsh.array(
+    borsh.struct([
+      borsh.struct(
+        [
+          borsh.publicKey("mint"),
+          borsh.u64("decimals"),
+          borsh.publicKey("tokenProgram"),
+          borsh.array(borsh.u64(), 6, "padding")
+        ],
+        "token"
+      ),
+      borsh.publicKey("rewardsVault"),
+      borsh.u64("rewardsAvailable"),
+      borsh.struct(
+        [
+          borsh.array(
+            borsh.struct([borsh.u64("tsStart"), borsh.u64("rewardPerTimeUnit")]),
+            20,
+            "points"
+          )
+        ],
+        "rewardScheduleCurve"
+      ),
+      borsh.u64("minClaimDurationSeconds"),
+      borsh.u64("lastIssuanceTs"),
+      borsh.u64("rewardsIssuedUnclaimed"),
+      borsh.u64("rewardsIssuedCumulative"),
+      borsh.u128("rewardPerShareScaled"),
+      borsh.u64("placeholder0"),
+      borsh.u8("rewardType"),
+      borsh.u8("rewardsPerSecondDecimals"),
+      borsh.array(borsh.u8(), 6, "padding0"),
+      borsh.array(borsh.u64(), 20, "padding1")
+    ]),
+    10,
+    "rewardInfos"
+  ),
+  borsh.u64("numRewardTokens"),
+  borsh.u64("numUsers"),
+  borsh.u64("totalStakedAmount"),
+  borsh.publicKey("farmVault"),
+  borsh.publicKey("farmVaultsAuthority"),
+  borsh.u64("farmVaultsAuthorityBump"),
+  borsh.publicKey("delegateAuthority"),
+  borsh.u8("timeUnit"),
+  borsh.u8("isFarmFrozen"),
+  borsh.u8("isFarmDelegated"),
+  borsh.array(borsh.u8(), 5, "padding0"),
+  borsh.publicKey("withdrawAuthority"),
+  borsh.u32("depositWarmupPeriod"),
+  borsh.u32("withdrawalCooldownPeriod"),
+  borsh.u128("totalActiveStakeScaled"),
+  borsh.u128("totalPendingStakeScaled"),
+  borsh.u64("totalPendingAmount"),
+  borsh.u64("slashedAmountCurrent"),
+  borsh.u64("slashedAmountCumulative"),
+  borsh.publicKey("slashedAmountSpillAddress"),
+  borsh.u64("lockingMode"),
+  borsh.u64("lockingStartTimestamp"),
+  borsh.u64("lockingDuration"),
+  borsh.u64("lockingEarlyWithdrawalPenaltyBps"),
+  borsh.u64("depositCapAmount"),
+  borsh.publicKey("scopePrices"),
+  borsh.u64("scopeOraclePriceId"),
+  borsh.u64("scopeOracleMaxAge"),
+  borsh.publicKey("pendingFarmAdmin"),
+  borsh.publicKey("strategyId"),
+  borsh.publicKey("delegatedRpsAdmin"),
+  borsh.publicKey("vaultId"),
+  borsh.publicKey("secondDelegatedAuthority"),
+  borsh.array(borsh.u64(), 74, "padding")
+]);
+function decodeFarmDataRaw(data) {
+  if (!data.slice(0, 8).equals(farmDiscriminator)) {
+    throw new Error("invalid account discriminator");
+  }
+  const dec = farmLayout.decode(data.slice(8));
+  return dec;
+}
+function dtoToKaminoFarmState(dto) {
+  return {
+    token: {
+      mint: new web3_js.PublicKey(dto.token.mint),
+      decimals: new BN9__default.default(dto.token.decimals)
+    },
+    rewardInfos: dto.rewardInfos.map((item) => ({
+      token: {
+        mint: new web3_js.PublicKey(item.token.mint),
+        decimals: new BN9__default.default(item.token.decimals)
+      },
+      rewardsAvailable: new BN9__default.default(item.rewardsAvailable),
+      rewardsPerSecondDecimals: item.rewardsPerSecondDecimals,
+      rewardScheduleCurve: {
+        points: item.rewardScheduleCurve.points.map((p) => ({
+          tsStart: new BN9__default.default(p.tsStart),
+          rewardPerTimeUnit: new BN9__default.default(p.rewardPerTimeUnit)
+        }))
+      }
+    }))
+  };
+}
+var KAMINO_PROGRAM_ID = new web3_js.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD");
+var FARMS_PROGRAM_ID2 = new web3_js.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
+function encodeU642(value) {
+  const buf = Buffer.alloc(8);
+  value.toArrayLike(Buffer, "le", 8).copy(buf);
+  return buf;
+}
+function encodeU8(value) {
+  const buf = Buffer.alloc(1);
+  buf.writeUInt8(value, 0);
+  return buf;
+}
+function encodeBool(value) {
+  const buf = Buffer.alloc(1);
+  buf.writeUInt8(value ? 1 : 0, 0);
+  return buf;
+}
+function encodeOptionBool(value) {
+  if (value === null || value === void 0) {
+    return Buffer.from([0]);
+  }
+  return Buffer.concat([Buffer.from([1]), encodeBool(value)]);
+}
+function encodeOptionU8(value) {
+  if (value === null || value === void 0) {
+    return Buffer.from([0]);
+  }
+  return Buffer.concat([Buffer.from([1]), encodeU8(value)]);
+}
+function encodePublicKey(pubkey) {
+  return Buffer.from(pubkey.toBytes());
+}
+var DISCRIMINATORS = {
+  MARGINFI_ACCOUNT_INITIALIZE: Buffer.from([43, 78, 61, 255, 148, 52, 249, 154]),
+  KAMINO_DEPOSIT: Buffer.from([237, 8, 188, 187, 115, 99, 49, 85]),
+  LENDING_ACCOUNT_DEPOSIT: Buffer.from([171, 94, 235, 103, 82, 64, 212, 140]),
+  LENDING_ACCOUNT_REPAY: Buffer.from([79, 209, 172, 177, 222, 51, 173, 151]),
+  KAMINO_WITHDRAW: Buffer.from([199, 101, 41, 45, 213, 98, 224, 200]),
+  LENDING_ACCOUNT_WITHDRAW: Buffer.from([36, 72, 74, 19, 210, 210, 192, 192]),
+  LENDING_ACCOUNT_BORROW: Buffer.from([4, 126, 116, 53, 48, 5, 212, 31]),
+  LENDING_ACCOUNT_LIQUIDATE: Buffer.from([214, 169, 151, 213, 251, 167, 86, 219]),
+  LENDING_POOL_ADD_BANK: Buffer.from([215, 68, 72, 78, 208, 218, 103, 182]),
+  LENDING_POOL_CONFIGURE_BANK: Buffer.from([121, 173, 156, 40, 93, 148, 56, 237]),
+  LENDING_ACCOUNT_START_FLASHLOAN: Buffer.from([14, 131, 33, 220, 81, 186, 180, 107]),
+  LENDING_ACCOUNT_END_FLASHLOAN: Buffer.from([105, 124, 201, 106, 153, 2, 8, 156]),
+  TRANSFER_TO_NEW_ACCOUNT: Buffer.from([28, 79, 129, 231, 169, 69, 69, 65]),
+  MARGINFI_GROUP_INITIALIZE: Buffer.from([255, 67, 67, 26, 94, 31, 34, 20]),
+  MARGINFI_ACCOUNT_CLOSE: Buffer.from([186, 221, 93, 34, 50, 97, 194, 241]),
+  LENDING_POOL_ADD_BANK_PERMISSIONLESS: Buffer.from([127, 187, 121, 34, 187, 167, 238, 102]),
+  LENDING_POOL_CONFIGURE_BANK_ORACLE: Buffer.from([209, 82, 255, 171, 124, 21, 71, 81]),
+  LENDING_ACCOUNT_PULSE_HEALTH: Buffer.from([186, 52, 117, 97, 34, 74, 39, 253]),
+  LENDING_ACCOUNT_SORT_BALANCES: Buffer.from([187, 194, 110, 84, 82, 170, 204, 9]),
+  DRIFT_DEPOSIT: Buffer.from([252, 63, 250, 201, 98, 55, 130, 12]),
+  DRIFT_WITHDRAW: Buffer.from([86, 59, 186, 123, 183, 181, 234, 137])
+};
+function makeInitMarginfiAccountIx2(programId, accounts) {
+  const keys = [
+    { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: true, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
+    {
+      pubkey: accounts.systemProgram || web3_js.SystemProgram.programId,
+      isSigner: false,
+      isWritable: false
+    }
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data: DISCRIMINATORS.MARGINFI_ACCOUNT_INITIALIZE
+  });
+}
+function makeDepositIx2(programId, accounts, args, remainingAccounts = []) {
+  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
+  const keys = [
+    { pubkey: accounts.group, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.bank, isSigner: false, isWritable: true },
+    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.liquidityVault ?? liquidityVault,
+      isSigner: false,
+      isWritable: true
+    },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
+  ];
+  keys.push(...remainingAccounts);
+  const data = Buffer.concat([
+    DISCRIMINATORS.LENDING_ACCOUNT_DEPOSIT,
+    encodeU642(args.amount),
+    encodeOptionBool(args.depositUpToLimit ?? null)
+  ]);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data
+  });
+}
+function makeRepayIx2(programId, accounts, args, remainingAccounts = []) {
+  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
+  const keys = [
+    { pubkey: accounts.group, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.bank, isSigner: false, isWritable: true },
+    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
+    { pubkey: liquidityVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
+  ];
+  keys.push(...remainingAccounts);
+  const data = Buffer.concat([
+    DISCRIMINATORS.LENDING_ACCOUNT_REPAY,
+    encodeU642(args.amount),
+    encodeOptionBool(args.repayAll ?? null)
+  ]);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data
+  });
+}
+function makeWithdrawIx2(programId, accounts, args, remainingAccounts = []) {
+  const [bankLiquidityVaultAuthority] = deriveBankLiquidityVaultAuthority(programId, accounts.bank);
+  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
+  const keys = [
+    { pubkey: accounts.group, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.bank, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.destinationTokenAccount,
+      isSigner: false,
+      isWritable: true
+    },
+    { pubkey: bankLiquidityVaultAuthority, isSigner: false, isWritable: false },
+    { pubkey: liquidityVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
+  ];
+  keys.push(...remainingAccounts);
+  const data = Buffer.concat([
+    DISCRIMINATORS.LENDING_ACCOUNT_WITHDRAW,
+    encodeU642(args.amount),
+    encodeOptionBool(args.withdrawAll ?? null)
+  ]);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data
+  });
+}
+function makeBorrowIx2(programId, accounts, args, remainingAccounts = []) {
+  const [bankLiquidityVaultAuthority] = deriveBankLiquidityVaultAuthority(programId, accounts.bank);
+  const [liquidityVault] = deriveBankLiquidityVault(programId, accounts.bank);
+  const keys = [
+    { pubkey: accounts.group, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.bank, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.destinationTokenAccount,
+      isSigner: false,
+      isWritable: true
+    },
+    { pubkey: bankLiquidityVaultAuthority, isSigner: false, isWritable: false },
+    { pubkey: liquidityVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false }
+  ];
+  keys.push(...remainingAccounts);
+  const data = Buffer.concat([DISCRIMINATORS.LENDING_ACCOUNT_BORROW, encodeU642(args.amount)]);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data
+  });
+}
+function makeBeginFlashLoanIx2(programId, accounts, args) {
+  const keys = [
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    {
+      pubkey: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
+      // hardcoded address from IDL
+      isSigner: false,
+      isWritable: false
+    }
+  ];
+  const data = Buffer.concat([
+    DISCRIMINATORS.LENDING_ACCOUNT_START_FLASHLOAN,
+    encodeU642(args.endIndex)
+  ]);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data
+  });
+}
+function makeEndFlashLoanIx2(programId, accounts, remainingAccounts = []) {
+  const keys = [
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false }
+  ];
+  keys.push(...remainingAccounts);
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId,
+    data: DISCRIMINATORS.LENDING_ACCOUNT_END_FLASHLOAN
+  });
+}
+function makeKaminoDepositIx2(programId, accounts, args, remainingAccounts = []) {
+  const liquidityVaultAuthority = deriveBankLiquidityVaultAuthority(programId, accounts.bank)[0];
+  const liquidityVault = deriveBankLiquidityVault(programId, accounts.bank)[0];
+  const keys = [
+    { pubkey: accounts.group, isSigner: false, isWritable: false },
+    { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.authority, isSigner: true, isWritable: false },
+    { pubkey: accounts.bank, isSigner: false, isWritable: true },
+    { pubkey: accounts.signerTokenAccount, isSigner: false, isWritable: true },
+    {
+      pubkey: liquidityVaultAuthority,
+      isSigner: false,
+      isWritable: true
+    },
+    { pubkey: liquidityVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.integrationAcc2, isSigner: false, isWritable: true },
+    { pubkey: accounts.lendingMarket, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.lendingMarketAuthority,
+      isSigner: false,
+      isWritable: false
+    },
+    { pubkey: accounts.integrationAcc1, isSigner: false, isWritable: true },
+    { pubkey: accounts.mint, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.reserveLiquiditySupply,
+      isSigner: false,
+      isWritable: true
+    },
+    {
+      pubkey: accounts.reserveCollateralMint,
+      isSigner: false,
+      isWritable: true
+    },
+    {
+      pubkey: accounts.reserveDestinationDepositCollateral,
+      isSigner: false,
+      isWritable: true
+    }
+  ];
+  if (accounts.obligationFarmUserState) {
+    keys.push({
+      pubkey: accounts.obligationFarmUserState,
+      isSigner: false,
+      isWritable: true
+    });
+  }
+  if (accounts.reserveFarmState) {
+    keys.push({
+      pubkey: accounts.reserveFarmState,
+      isSigner: false,
+      isWritable: true
     });
   }
   keys.push(
@@ -63241,7 +66627,7 @@ function makeKaminoDepositIx2(programId, accounts, args, remainingAccounts = [])
   keys.push(...remainingAccounts);
   const data = Buffer.concat([
     DISCRIMINATORS.KAMINO_DEPOSIT,
-    encodeU64(args.amount),
+    encodeU642(args.amount),
     encodeOptionBool(args.refreshReserve ?? null)
   ]);
   return new web3_js.TransactionInstruction({ keys, programId, data });
@@ -63319,7 +66705,7 @@ function makeKaminoWithdrawIx2(programId, accounts, args, remainingAccounts = []
   const flags = (args.isFinalWithdrawal ? 1 : 0) | (args.refreshReserve ? 2 : 0);
   const data = Buffer.concat([
     DISCRIMINATORS.KAMINO_WITHDRAW,
-    encodeU64(args.amount),
+    encodeU642(args.amount),
     encodeOptionU8(flags === 0 ? null : flags)
   ]);
   return new web3_js.TransactionInstruction({ keys, programId, data });
@@ -63352,7 +66738,7 @@ function makeLendingAccountLiquidateIx2(programId, accounts, args, remainingAcco
   keys.push(...remainingAccounts);
   const data = Buffer.concat([
     DISCRIMINATORS.LENDING_ACCOUNT_LIQUIDATE,
-    encodeU64(args.assetAmount),
+    encodeU642(args.assetAmount),
     Buffer.from([args.liquidateeAccounts]),
     Buffer.from([args.liquidatorAccounts])
   ]);
@@ -63510,7 +66896,7 @@ function makeDriftDepositIx2(programId, accounts, args) {
     { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
     { pubkey: accounts.systemProgram, isSigner: false, isWritable: false }
   );
-  const data = Buffer.concat([DISCRIMINATORS.DRIFT_DEPOSIT, encodeU64(args.amount)]);
+  const data = Buffer.concat([DISCRIMINATORS.DRIFT_DEPOSIT, encodeU642(args.amount)]);
   return new web3_js.TransactionInstruction({ keys, programId, data });
 }
 function makeDriftWithdrawIx2(programId, accounts, args, remainingAccounts = []) {
@@ -63596,7 +66982,7 @@ function makeDriftWithdrawIx2(programId, accounts, args, remainingAccounts = [])
   keys.push(...remainingAccounts);
   const data = Buffer.concat([
     DISCRIMINATORS.DRIFT_WITHDRAW,
-    encodeU64(args.amount),
+    encodeU642(args.amount),
     encodeBool(args.withdrawAll)
   ]);
   return new web3_js.TransactionInstruction({ keys, programId, data });
@@ -63636,7 +67022,7 @@ function makePoolAddPermissionlessStakedBankIx2(programId, accounts, remainingAc
   keys.push(...remainingAccounts);
   const data = Buffer.concat([
     DISCRIMINATORS.LENDING_POOL_ADD_BANK_PERMISSIONLESS,
-    encodeU64(args.seed || new BN9__default.default(0))
+    encodeU642(args.seed || new BN9__default.default(0))
   ]);
   return new web3_js.TransactionInstruction({
     keys,
@@ -66681,14 +70067,14 @@ function computeV0TxSize(ixs, payerKey, luts) {
     if (!keyMap.has(progStr)) {
       keyMap.set(progStr, { isSigner: false, isWritable: false });
     }
-    for (const meta of ix.keys) {
-      const keyStr = meta.pubkey.toBase58();
+    for (const meta2 of ix.keys) {
+      const keyStr = meta2.pubkey.toBase58();
       const existing = keyMap.get(keyStr);
       if (existing) {
-        existing.isSigner = existing.isSigner || meta.isSigner;
-        existing.isWritable = existing.isWritable || meta.isWritable;
+        existing.isSigner = existing.isSigner || meta2.isSigner;
+        existing.isWritable = existing.isWritable || meta2.isWritable;
       } else {
-        keyMap.set(keyStr, { isSigner: meta.isSigner, isWritable: meta.isWritable });
+        keyMap.set(keyStr, { isSigner: meta2.isSigner, isWritable: meta2.isWritable });
       }
     }
   }
@@ -70724,6 +74110,13 @@ async function computeSmartCrank({
       isCrankable: true
     });
   }
+  const activeEmodeWeightsByBank = computeLowestEmodeWeights(
+    computeActiveEmodePairs(
+      getEmodePairs(Array.from(bankMap.values())),
+      liabilityBalances.map((b) => b.bankPk),
+      assetBalances.map((b) => b.bankPk)
+    )
+  );
   const getBanks = (balances) => balances.map((b) => bankMap.get(b.bankPk.toBase58())).filter((bank) => bank !== void 0);
   const projectedAssetBanks = getBanks(assetBalances);
   const liabilityBanks = getBanks(liabilityBalances);
@@ -70808,7 +74201,8 @@ async function computeSmartCrank({
       oraclePricesByBank: oraclePrices,
       assetBanks: nonSWBAssets.map((b) => b.address),
       marginRequirement: 0 /* Initial */,
-      assetShareValueMultiplierByBank
+      assetShareValueMultiplierByBank,
+      activeEmodeWeightsByBank
     });
     const healthDiff = nonSWBAssetsHealth.minus(totalLiabilitiesInitHealth);
     if (healthDiff.gt(0)) {
@@ -70848,7 +74242,8 @@ async function computeSmartCrank({
     oraclePricesByBank: oraclePrices,
     assetBanks: allAvailableAssetAddresses,
     marginRequirement: 0 /* Initial */,
-    assetShareValueMultiplierByBank
+    assetShareValueMultiplierByBank,
+    activeEmodeWeightsByBank
   });
   const healthWithAllAssets = allAssetsHealth.minus(totalLiabilitiesInitHealth);
   if (!healthWithAllAssets.gt(0)) {
@@ -70885,7 +74280,8 @@ async function computeSmartCrank({
         oraclePricesByBank: oraclePrices,
         assetBanks: [...nonSWBAssetAddresses, ...comboAddresses],
         marginRequirement: 0 /* Initial */,
-        assetShareValueMultiplierByBank
+        assetShareValueMultiplierByBank,
+        activeEmodeWeightsByBank
       });
       const health = comboHealth.minus(totalLiabilitiesInitHealth);
       if (!health.gt(0)) continue;
@@ -73311,6 +76707,274 @@ async function makeMergeStakeAccountsTx(params) {
     type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
   });
 }
+
+// src/services/vaults/utils/fetch.utils.ts
+async function fetchGammaLpVault(connection, lpVault) {
+  const info = await connection.getAccountInfo(lpVault);
+  if (!info) {
+    throw new Error(`Gamma LpVault account not found: ${lpVault.toBase58()}`);
+  }
+  return decodeGammaLpVaultData(info.data, lpVault);
+}
+async function fetchGammaWithdrawReceipt(connection, user, lpVault) {
+  const [receipt] = deriveGammaWithdrawReceipt(user, lpVault);
+  const info = await connection.getAccountInfo(receipt);
+  if (!info) return null;
+  return decodeGammaWithdrawReceiptData(info.data, receipt);
+}
+async function resolveVaultTokenProgram(connection, assetsMint) {
+  const info = await connection.getAccountInfo(assetsMint);
+  if (info && info.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+    return TOKEN_2022_PROGRAM_ID;
+  }
+  return TOKEN_PROGRAM_ID;
+}
+async function makeVaultDepositIx(params) {
+  const { amount, user, lpVault, connection } = params;
+  const vault = await fetchGammaLpVault(connection, lpVault);
+  const tokenProgram = params.tokenProgram ?? await resolveVaultTokenProgram(connection, vault.assetsMint);
+  const [withdrawalPolicy] = deriveGammaWithdrawalPolicy(lpVault);
+  const [depositReceipt] = deriveGammaDepositReceipt(user, lpVault);
+  const userAssetAta = deriveGammaAta(vault.assetsMint, user, tokenProgram);
+  const userShareAta = deriveGammaAta(vault.sharesMint, user, tokenProgram);
+  const amountNative = new BN9__default.default(new BigNumber3__default.default(amount).toFixed(0));
+  const wrapIxs = vault.assetsMint.equals(WSOL_MINT) ? makeWrapSolIxs(user, new BigNumber3__default.default(amountNative.toString()).shiftedBy(-9)) : [];
+  const createShareAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+    user,
+    userShareAta,
+    user,
+    vault.sharesMint,
+    tokenProgram
+  );
+  const ix = makeGammaDepositIx(
+    {
+      user,
+      lpVault,
+      withdrawalPolicy,
+      assetsAccount: vault.assetsAccount,
+      userAssetAta,
+      userShareAta,
+      depositReceipt,
+      assetsMint: vault.assetsMint,
+      sharesMint: vault.sharesMint,
+      tokenProgram
+    },
+    amountNative
+  );
+  const instructions2 = [
+    ...wrapIxs,
+    createShareAtaIx,
+    ix
+  ];
+  return { instructions: instructions2, keys: [] };
+}
+async function makeVaultDepositTx(params) {
+  const { connection, user, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeVaultDepositIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: user,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "VAULT_DEPOSIT" /* VAULT_DEPOSIT */
+  });
+}
+async function makeVaultDepositWithSwapTx(params) {
+  const {
+    user,
+    lpVault,
+    connection,
+    inputMint,
+    inputAmount,
+    inputDecimals,
+    swapOpts,
+    swapEngineRunner,
+    luts,
+    blockhash: providedBlockhash
+  } = params;
+  const vault = await fetchGammaLpVault(connection, lpVault);
+  const mintInfo = await connection.getAccountInfo(vault.assetsMint);
+  if (!mintInfo) {
+    throw new Error(`Vault asset mint not found: ${vault.assetsMint.toBase58()}`);
+  }
+  const tokenProgram = params.tokenProgram ?? (mintInfo.owner.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID);
+  const assetDecimals = mintInfo.data[44];
+  const [withdrawalPolicy] = deriveGammaWithdrawalPolicy(lpVault);
+  const [depositReceipt] = deriveGammaDepositReceipt(user, lpVault);
+  const userAssetAta = deriveGammaAta(vault.assetsMint, user, tokenProgram);
+  const userShareAta = deriveGammaAta(vault.sharesMint, user, tokenProgram);
+  const createShareAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+    user,
+    userShareAta,
+    user,
+    vault.sharesMint,
+    tokenProgram
+  );
+  const depositAccounts = {
+    user,
+    lpVault,
+    withdrawalPolicy,
+    assetsAccount: vault.assetsAccount,
+    userAssetAta,
+    userShareAta,
+    depositReceipt,
+    assetsMint: vault.assetsMint,
+    sharesMint: vault.sharesMint,
+    tokenProgram
+  };
+  const inputAmountBn = new BigNumber3__default.default(inputAmount);
+  const isNativeSol = new web3_js.PublicKey(inputMint).equals(WSOL_MINT);
+  const wrapIxs = isNativeSol ? makeWrapSolIxs(user, inputAmountBn) : [];
+  const amountNative = uiToNative(inputAmountBn, inputDecimals);
+  const placeholderDepositIx = makeGammaDepositIx(depositAccounts, new BN9__default.default(0));
+  const runEngine = swapEngineRunner ?? runSwapEngine;
+  const engineResult = await runEngine({
+    inputMint,
+    outputMint: vault.assetsMint.toBase58(),
+    amountNative: amountNative.toNumber(),
+    inputDecimals,
+    outputDecimals: assetDecimals,
+    ...swapEngineQuoteFieldsFromOpts(swapOpts),
+    taker: user,
+    destinationTokenAccount: userAssetAta,
+    connection,
+    footprint: {
+      instructions: [...wrapIxs, createShareAtaIx, placeholderDepositIx],
+      luts: luts ?? [],
+      payer: user,
+      // Non-flashloan single tx: the swap may use the full tx budget.
+      sizeConstraint: MAX_TX_SIZE,
+      maxSwapTotalAccounts: MAX_ACCOUNT_LOCKS
+    },
+    providers: swapEngineProvidersFromOpts(swapOpts)
+  });
+  const depositIx = makeGammaDepositIx(
+    depositAccounts,
+    engineResult.outputAmountNative
+  );
+  const instructions2 = [
+    ...wrapIxs,
+    createShareAtaIx,
+    ...engineResult.setupInstructions,
+    ...engineResult.swapInstructions,
+    depositIx
+  ];
+  const allLuts = [...luts ?? [], ...engineResult.swapLuts];
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: user,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(allLuts);
+  const tx = new web3_js.VersionedTransaction(message);
+  if (getTxSize(tx) > MAX_TX_SIZE || getTotalAccountKeys(tx) > MAX_ACCOUNT_LOCKS) {
+    throw new Error(
+      "vault deposit-with-swap: swap route too large to fit in one transaction"
+    );
+  }
+  return {
+    transaction: addTransactionMetadata(tx, {
+      signers: [],
+      addressLookupTables: allLuts,
+      type: "VAULT_DEPOSIT" /* VAULT_DEPOSIT */
+    }),
+    quoteResponse: engineResult.quoteResponse,
+    destinationAmount: nativeToUi(engineResult.outputAmountNative, assetDecimals)
+  };
+}
+async function makeVaultWithdrawIx(params) {
+  const { sharesAmount, user, lpVault, connection } = params;
+  const vault = await fetchGammaLpVault(connection, lpVault);
+  const tokenProgram = params.tokenProgram ?? await resolveVaultTokenProgram(connection, vault.assetsMint);
+  const [withdrawalPolicy] = deriveGammaWithdrawalPolicy(lpVault);
+  const [withdrawEscrow] = deriveGammaWithdrawEscrow(user, lpVault);
+  const [withdrawReceipt] = deriveGammaWithdrawReceipt(user, lpVault);
+  const userShareAta = deriveGammaAta(vault.sharesMint, user, tokenProgram);
+  const feeRecipientAccount = deriveGammaAta(vault.assetsMint, vault.feeRecipient, tokenProgram);
+  const escrowAssetsAccount = deriveGammaAta(vault.assetsMint, withdrawEscrow, tokenProgram);
+  const escrowSharesAccount = deriveGammaAta(vault.sharesMint, withdrawEscrow, tokenProgram);
+  const sharesNative = new BN9__default.default(new BigNumber3__default.default(sharesAmount).toFixed(0));
+  const ix = makeGammaWithdrawIx(
+    {
+      user,
+      lpVault,
+      withdrawalPolicy,
+      assetsAccount: vault.assetsAccount,
+      userShareAta,
+      assetsMint: vault.assetsMint,
+      sharesMint: vault.sharesMint,
+      feeRecipientAccount,
+      withdrawEscrow,
+      escrowAssetsAccount,
+      escrowSharesAccount,
+      withdrawReceipt,
+      tokenProgram
+    },
+    sharesNative
+  );
+  const instructions2 = [ix];
+  return { instructions: instructions2, keys: [] };
+}
+async function makeVaultWithdrawTx(params) {
+  const { connection, user, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeVaultWithdrawIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: user,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "VAULT_WITHDRAW" /* VAULT_WITHDRAW */
+  });
+}
+async function makeVaultCompleteWithdrawalIx(params) {
+  const { user, lpVault, connection } = params;
+  const vault = await fetchGammaLpVault(connection, lpVault);
+  const tokenProgram = params.tokenProgram ?? await resolveVaultTokenProgram(connection, vault.assetsMint);
+  const [withdrawEscrow] = deriveGammaWithdrawEscrow(user, lpVault);
+  const [withdrawReceipt] = deriveGammaWithdrawReceipt(user, lpVault);
+  const userAssetAta = deriveGammaAta(vault.assetsMint, user, tokenProgram);
+  const escrowAssetsAccount = deriveGammaAta(vault.assetsMint, withdrawEscrow, tokenProgram);
+  const escrowSharesAccount = deriveGammaAta(vault.sharesMint, withdrawEscrow, tokenProgram);
+  const ix = makeGammaCompleteWithdrawalIx({
+    user,
+    lpVault,
+    assetsMint: vault.assetsMint,
+    sharesMint: vault.sharesMint,
+    userAssetAta,
+    withdrawEscrow,
+    escrowAssetsAccount,
+    escrowSharesAccount,
+    withdrawReceipt,
+    tokenProgram
+  });
+  return { instructions: [ix], keys: [] };
+}
+async function makeVaultCompleteWithdrawalTx(params) {
+  const { connection, user, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeVaultCompleteWithdrawalIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: user,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "VAULT_COMPLETE_WITHDRAWAL" /* VAULT_COMPLETE_WITHDRAWAL */
+  });
+}
 async function getKaminoMetadata(options) {
   const kaminoBanks = options.banks.filter((b) => b.config.assetTag === 3 /* KAMINO */);
   const DEFAULT_PUBKEY = web3_js.PublicKey.default;
@@ -75366,6 +79030,8 @@ exports.emodeSettingsRawToDto = emodeSettingsRawToDto;
 exports.extractPythOracleKeys = extractPythOracleKeys;
 exports.fetchBank = fetchBank;
 exports.fetchBankIntegrationMetadata = fetchBankIntegrationMetadata;
+exports.fetchGammaLpVault = fetchGammaLpVault;
+exports.fetchGammaWithdrawReceipt = fetchGammaWithdrawReceipt;
 exports.fetchMarginfiAccountActiveBalancesForBank = fetchMarginfiAccountActiveBalancesForBank;
 exports.fetchMarginfiAccountAddresses = fetchMarginfiAccountAddresses;
 exports.fetchMarginfiAccountAddressesHoldingBank = fetchMarginfiAccountAddressesHoldingBank;
@@ -75507,6 +79173,13 @@ exports.makeUnwrapSolIx = makeUnwrapSolIx;
 exports.makeUpdateDriftMarketIxs = makeUpdateDriftMarketIxs;
 exports.makeUpdateJupLendRateIxs = makeUpdateJupLendRateIxs;
 exports.makeUpdateSwbFeedIx = makeUpdateSwbFeedIx;
+exports.makeVaultCompleteWithdrawalIx = makeVaultCompleteWithdrawalIx;
+exports.makeVaultCompleteWithdrawalTx = makeVaultCompleteWithdrawalTx;
+exports.makeVaultDepositIx = makeVaultDepositIx;
+exports.makeVaultDepositTx = makeVaultDepositTx;
+exports.makeVaultDepositWithSwapTx = makeVaultDepositWithSwapTx;
+exports.makeVaultWithdrawIx = makeVaultWithdrawIx;
+exports.makeVaultWithdrawTx = makeVaultWithdrawTx;
 exports.makeVersionedTransaction = makeVersionedTransaction;
 exports.makeWithdrawIx = makeWithdrawIx3;
 exports.makeWithdrawTx = makeWithdrawTx;
@@ -75539,6 +79212,7 @@ exports.partitionBanksByCrankability = partitionBanksByCrankability;
 exports.patchDepositAmount = patchDepositAmount;
 exports.resolveAmount = resolveAmount;
 exports.resolveBridgeBanks = resolveBridgeBanks;
+exports.resolveVaultTokenProgram = resolveVaultTokenProgram;
 exports.runSwapEngine = runSwapEngine;
 exports.selectLutsForAccountAction = selectLutsForAccountAction;
 exports.selectLutsForBanks = selectLutsForBanks;