@perena/vault-sdk 1.0.28 → 1.0.29

package/dist/index.js

@@ -150,7 +150,7 @@ var require_compat = __commonJS({
     exports2.toWeb3PublicKey = toWeb3PublicKey;
     exports2.asWeb3PublicKey = asWeb3PublicKey2;
     exports2.toKitInstruction = toKitInstruction30;
-    exports2.fromKitInstruction = fromKitInstruction2;
+    exports2.fromKitInstruction = fromKitInstruction3;
     var kit_1 = require("@solana/kit");
     var web3_js_1 = require("@solana/web3.js");
     function fromWeb3PublicKey(pubkey) {
@@ -175,7 +175,7 @@ var require_compat = __commonJS({
         }))
       };
     }
-    function fromKitInstruction2(ix) {
+    function fromKitInstruction3(ix) {
       return new web3_js_1.TransactionInstruction({
         programId: toWeb3PublicKey(ix.programAddress),
         keys: (ix.accounts ?? []).map((account) => ({
@@ -342,7 +342,7 @@ var require_refs = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createMultiCpiRefs = createMultiCpiRefs;
-    exports2.createCpiRefs = createCpiRefs3;
+    exports2.createCpiRefs = createCpiRefs4;
     var kit_1 = require("@solana/kit");
     var roles_1 = require_roles();
     var accounts_1 = require_accounts();
@@ -478,7 +478,7 @@ var require_refs = __commonJS({
         lookupTables: collectLookupTables(allCpis)
       };
     }
-    function createCpiRefs3(cpis, options) {
+    function createCpiRefs4(cpis, options) {
       const accountLists = toCpiAccountLists(cpis);
       const { pool, poolIndex } = buildPool(accountLists, options);
       const trackedIndices = resolveTrackedIndices(poolIndex, options?.trackAddresses);
@@ -592,11 +592,11 @@ var require_transaction = __commonJS({
   "../common/dist/utils/transaction.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.fetchLookupTables = fetchLookupTables2;
+    exports2.fetchLookupTables = fetchLookupTables3;
     exports2.getSignatureStatus = getSignatureStatus;
     exports2.sendVersionedTransaction = sendVersionedTransaction;
     var web3_js_1 = require("@solana/web3.js");
-    async function fetchLookupTables2(connection, lookupTables) {
+    async function fetchLookupTables3(connection, lookupTables) {
       const accounts2 = await Promise.all(lookupTables.map(async (lookupTable) => {
         const response = await connection.getAddressLookupTable(new web3_js_1.PublicKey(lookupTable));
         if (!response.value) {
@@ -613,7 +613,7 @@ var require_transaction = __commonJS({
     }
     async function sendVersionedTransaction({ connection, payer, instructions: instructions2, lookupTables }) {
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-      const lookupTableAccounts = await fetchLookupTables2(connection, lookupTables);
+      const lookupTableAccounts = await fetchLookupTables3(connection, lookupTables);
       const message2 = new web3_js_1.TransactionMessage({
         payerKey: payer.publicKey,
         recentBlockhash: blockhash,
@@ -2921,7 +2921,7 @@ var require_client = __commonJS({
     var extract_1 = require_extract();
     var routePreInstructions_1 = require_routePreInstructions();
     var constants_1 = require_constants4();
-    var JupiterSwapClient = class {
+    var JupiterSwapClient2 = class {
       constructor(rpc, config = {}) {
         this.rpc = rpc;
         this.config = config;
@@ -3012,7 +3012,7 @@ var require_client = __commonJS({
         };
       }
     };
-    exports2.JupiterSwapClient = JupiterSwapClient;
+    exports2.JupiterSwapClient = JupiterSwapClient2;
   }
 });
 
@@ -3232,6 +3232,7 @@ var require_dist4 = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   ASSET_DECIMALS: () => ASSET_DECIMALS,
+  ASSET_REBALANCE_COOLDOWN_SECS: () => ASSET_REBALANCE_COOLDOWN_SECS,
   AccountClient: () => AccountClient,
   ActivateCircuitBreakerBuilder: () => ActivateCircuitBreakerBuilder,
   CONSENSUS_ORACLE_VARIANT: () => CONSENSUS_ORACLE_VARIANT,
@@ -3242,15 +3243,20 @@ __export(index_exports, {
   CreateAssetHoldingBuilder: () => CreateAssetHoldingBuilder,
   CreateTrancheStateBuilder: () => CreateTrancheStateBuilder,
   CreateVaultBuilder: () => CreateVaultBuilder,
+  DEFAULT_CU_PRICE_MICRO_LAMPORTS: () => DEFAULT_CU_PRICE_MICRO_LAMPORTS,
   DEFAULT_JUNIOR_EARLY_UNSTAKE_FEE_BPS: () => DEFAULT_JUNIOR_EARLY_UNSTAKE_FEE_BPS,
   DEFAULT_JUNIOR_STANDARD_UNSTAKE_FEE_BPS: () => DEFAULT_JUNIOR_STANDARD_UNSTAKE_FEE_BPS,
   DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS: () => DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS,
   DEFAULT_MAX_ACCEPTABLE_APY_BPS: () => DEFAULT_MAX_ACCEPTABLE_APY_BPS,
+  DEFAULT_MAX_ACCOUNTS: () => DEFAULT_MAX_ACCOUNTS,
   DEFAULT_MIN_AMOUNT_UI: () => DEFAULT_MIN_AMOUNT_UI,
   DEFAULT_ORACLE_STALENESS_THRESHOLD_SECS: () => DEFAULT_ORACLE_STALENESS_THRESHOLD_SECS,
   DEFAULT_PRICE_ORACLE_ACCOUNT: () => DEFAULT_PRICE_ORACLE_ACCOUNT,
   DEFAULT_PRICE_STALENESS_SECS: () => DEFAULT_PRICE_STALENESS_SECS,
   DEFAULT_PRICE_STALENESS_THRESHOLD_SECS: () => DEFAULT_PRICE_STALENESS_THRESHOLD_SECS,
+  DEFAULT_REBALANCE_BAND_BPS: () => DEFAULT_REBALANCE_BAND_BPS,
+  DEFAULT_SLIPPAGE_BPS: () => DEFAULT_SLIPPAGE_BPS,
+  DEFAULT_TARGET_LOCAL_BPS: () => DEFAULT_TARGET_LOCAL_BPS,
   DEFAULT_VAULT_ID: () => DEFAULT_VAULT_ID,
   DisableCircuitBreakerBuilder: () => DisableCircuitBreakerBuilder,
   EXTERNAL_POSITION_SAMPLES: () => EXTERNAL_POSITION_SAMPLES,
@@ -3264,6 +3270,9 @@ __export(index_exports, {
   FEE_VAULT_CACHE_CATEGORY: () => FEE_VAULT_CACHE_CATEGORY,
   FulfillJuniorTrancheWithdrawBuilder: () => FulfillJuniorTrancheWithdrawBuilder,
   IDL: () => IDL,
+  IDLE_RESERVE_FLOOR_BPS: () => IDLE_RESERVE_FLOOR_BPS,
+  IDLE_RESERVE_TARGET_BPS: () => IDLE_RESERVE_TARGET_BPS,
+  IdleLiquidityService: () => IdleLiquidityService,
   InitializeVaultRolesBuilder: () => InitializeVaultRolesBuilder,
   JupiterBalanceSource: () => JupiterBalanceSource,
   JupiterPriceSource: () => JupiterPriceSource,
@@ -3377,6 +3386,7 @@ __export(index_exports, {
   mintTokensTo: () => mintTokensTo,
   mostFrequent: () => mostFrequent,
   parseExternalLiquidityRefs: () => parseExternalLiquidityRefs,
+  planRebalance: () => planRebalance,
   prepareVaultTransaction: () => prepareVaultTransaction,
   priceInAccountingUnit: () => priceInAccountingUnit,
   readI64LE: () => readI64LE,
@@ -14326,6 +14336,106 @@ var IDL = {
         ]
       }
     },
+    {
+      "name": "RollingRebalanceLimit",
+      "docs": [
+        "Rolling-window cap on rebalance (Jupiter swap) throughput, expressed as a",
+        "share of current TVL rather than a fixed amount.",
+        "",
+        "Sibling of [`super::withdrawal_limits::RollingWithdrawalLimit`]: same",
+        "window-slide-then-charge mechanics, but the ceiling is recomputed from live",
+        "TVL on every call, so the cap tracks the vault as it grows or shrinks",
+        "instead of going stale at whatever amount the curator last set.",
+        "",
+        "Both swap directions charge the same window \u2014 the cap bounds total value",
+        "routed through Jupiter per window, regardless of which asset is sold."
+      ],
+      "serialization": "bytemuck",
+      "repr": {
+        "kind": "c"
+      },
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "window_start_ts",
+            "docs": [
+              "Unix timestamp the current window opened."
+            ],
+            "type": "i64"
+          },
+          {
+            "name": "window_duration_seconds",
+            "docs": [
+              "Window length, in seconds (e.g. 3_600 for an hourly limit)."
+            ],
+            "type": "u64"
+          },
+          {
+            "name": "value_in_window",
+            "docs": [
+              "Value rebalanced inside the current window, in the vault's accounting",
+              "unit."
+            ],
+            "type": "u64"
+          },
+          {
+            "name": "window_limit_bps",
+            "docs": [
+              "Cap as a share of TVL, in bps. `0` disables the limit."
+            ],
+            "type": "u16"
+          },
+          {
+            "name": "_padding1",
+            "type": {
+              "array": [
+                "u8",
+                6
+              ]
+            }
+          },
+          {
+            "name": "_padding2",
+            "type": {
+              "array": [
+                "u64",
+                4
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      "name": "RollingRebalanceLimitConfig",
+      "docs": [
+        "Rolling rebalance-limit config applied via [`SetVaultConfigArgs`].",
+        "",
+        "The cap is a share of TVL rather than a fixed amount, so it stays",
+        "meaningful as the vault grows. Both fields must be zero (disable the cap)",
+        "or both non-zero (enable it)."
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "window_limit_bps",
+            "docs": [
+              "Max share of TVL rebalanced inside one window, in bps (`0` disables)."
+            ],
+            "type": "u16"
+          },
+          {
+            "name": "window_duration_seconds",
+            "docs": [
+              "Window length in seconds (`0` only valid when `window_limit_bps` is `0`)."
+            ],
+            "type": "u64"
+          }
+        ]
+      }
+    },
     {
       "name": "SetAssetPriceOracleArgs",
       "type": {
@@ -14511,6 +14621,20 @@ var IDL = {
                 }
               }
             }
+          },
+          {
+            "name": "rebalance_limit",
+            "docs": [
+              "Rolling cap on rebalance (Jupiter swap) throughput. `None` leaves",
+              "unchanged."
+            ],
+            "type": {
+              "option": {
+                "defined": {
+                  "name": "RollingRebalanceLimitConfig"
+                }
+              }
+            }
           }
         ]
       }
@@ -15432,6 +15556,14 @@ var IDL = {
             "name": "senior_fixed_apy_bps",
             "type": "u16"
           },
+          {
+            "name": "junior_floor_apy_bps",
+            "docs": [
+              "Floor APY for the junior tranche, in basis points. Zero disables the",
+              "floor. Shortfalls are funded from the untranched sleeve, never senior."
+            ],
+            "type": "u16"
+          },
           {
             "name": "early_unstake_fee_bps",
             "type": "u16"
@@ -16257,12 +16389,38 @@ var IDL = {
             ],
             "type": "u64"
           },
+          {
+            "name": "junior_floor_apy_bps",
+            "docs": [
+              "Curator-set floor APY for the junior tranche, in basis points. Zero",
+              "disables the floor.",
+              "",
+              "When junior's realized growth falls short of this floor, the shortfall is",
+              "topped up from the *untranched* (regular) sleeve's value, never from the",
+              "senior tranche -- senior's fixed-APY entitlement is settled first and is",
+              "untouched by the floor. The top-up is best-effort: it is capped by the",
+              "untranched sleeve's available value, and any unpaid remainder stays",
+              "outstanding against the durable junior anchor",
+              "(`VaultTrancheState::junior_apy_anchor_share_price`) so it can be paid on",
+              "a later settlement."
+            ],
+            "type": "u16"
+          },
+          {
+            "name": "_padding1",
+            "type": {
+              "array": [
+                "u8",
+                6
+              ]
+            }
+          },
           {
             "name": "_padding2",
             "type": {
               "array": [
                 "u64",
-                13
+                12
               ]
             }
           }
@@ -16340,12 +16498,28 @@ var IDL = {
             ],
             "type": "i64"
           },
+          {
+            "name": "junior_apy_anchor_share_price",
+            "docs": [
+              "Junior share price at the start of the current floor-APY regime. The",
+              "anchor is durable across settlements so an unpaid floor shortfall stays",
+              "outstanding and can be caught up later."
+            ],
+            "type": "u64"
+          },
+          {
+            "name": "junior_apy_anchor_ts",
+            "docs": [
+              "Unix timestamp when the junior floor-APY anchor was set."
+            ],
+            "type": "i64"
+          },
           {
             "name": "_padding2",
             "type": {
               "array": [
                 "u64",
-                29
+                27
               ]
             }
           }
@@ -16363,6 +16537,17 @@ var IDL = {
               "option": "u16"
             }
           },
+          {
+            "name": "junior_floor_apy_bps",
+            "docs": [
+              "Floor APY for the junior tranche, in basis points. Zero disables the",
+              "floor. Setting this starts a fresh regime: any shortfall accrued under",
+              "the previous value is forfeited."
+            ],
+            "type": {
+              "option": "u16"
+            }
+          },
           {
             "name": "early_unstake_fee_bps",
             "type": {
@@ -16645,12 +16830,25 @@ var IDL = {
             ],
             "type": "u64"
           },
+          {
+            "name": "rebalance_limit",
+            "docs": [
+              "Rolling cap on rebalance (Jupiter swap) throughput per window, as a",
+              "share of TVL. Carved out of `_padding1`, so the account layout and size",
+              "are unchanged and existing vaults decode it as disabled."
+            ],
+            "type": {
+              "defined": {
+                "name": "RollingRebalanceLimit"
+              }
+            }
+          },
           {
             "name": "_padding1",
             "type": {
               "array": [
                 "u64",
-                30
+                22
               ]
             }
           },
@@ -17789,6 +17987,7 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.vaultCreateTrancheState({
       seniorFixedApyBps: args.seniorFixedApyBps,
+      juniorFloorApyBps: args.juniorFloorApyBps,
       earlyUnstakeFeeBps: args.earlyUnstakeFeeBps,
       standardUnstakeFeeBps: args.standardUnstakeFeeBps,
       targetLockupDurationSecs: args.targetLockupDurationSecs,
@@ -17832,6 +18031,7 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
       seniorShareMint: txArgs.seniorShareMint,
       vaultOracle,
       seniorFixedApyBps: txArgs.seniorFixedApyBps ?? 0,
+      juniorFloorApyBps: txArgs.juniorFloorApyBps ?? 0,
       earlyUnstakeFeeBps: txArgs.earlyUnstakeFeeBps ?? DEFAULT_JUNIOR_EARLY_UNSTAKE_FEE_BPS,
       standardUnstakeFeeBps: txArgs.standardUnstakeFeeBps ?? DEFAULT_JUNIOR_STANDARD_UNSTAKE_FEE_BPS,
       targetLockupDurationSecs: new import_core.BN(
@@ -17907,7 +18107,8 @@ function toAnchorSetVaultConfigArgs(args) {
     lossesEnabled: args.lossesEnabled,
     priceStalenessThresholdSecs: args.priceStalenessThresholdSecs,
     userBurnLimit: args.userBurnLimit,
-    managerPullLimit: args.managerPullLimit
+    managerPullLimit: args.managerPullLimit,
+    rebalanceLimit: args.rebalanceLimit
   };
 }
 function toAnchorConsensusUpdates(updates) {
@@ -18115,6 +18316,12 @@ var SetVaultConfigBuilder = class extends VaultBuilderBase {
           windowDurationSeconds: new import_core4.BN(
             txArgs.managerPullLimit.windowDurationSeconds.toString()
           )
+        } : null,
+        rebalanceLimit: txArgs.rebalanceLimit !== void 0 ? {
+          windowLimitBps: txArgs.rebalanceLimit.windowLimitBps,
+          windowDurationSeconds: new import_core4.BN(
+            txArgs.rebalanceLimit.windowDurationSeconds.toString()
+          )
         } : null
       }
     };
@@ -19499,6 +19706,7 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.vaultUpdateTrancheConfig({
       seniorFixedApyBps: args.seniorFixedApyBps,
+      juniorFloorApyBps: args.juniorFloorApyBps,
       earlyUnstakeFeeBps: args.earlyUnstakeFeeBps,
       standardUnstakeFeeBps: args.standardUnstakeFeeBps,
       targetLockupDurationSecs: args.targetLockupDurationSecs,
@@ -19521,6 +19729,7 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
       vaultTrancheState: txArgs.vaultTrancheState ?? vaultTrancheState,
       vaultOracle: txArgs.vaultOracle ?? vaultOracle,
       seniorFixedApyBps: txArgs.seniorFixedApyBps ?? null,
+      juniorFloorApyBps: txArgs.juniorFloorApyBps ?? null,
       earlyUnstakeFeeBps: txArgs.earlyUnstakeFeeBps ?? null,
       standardUnstakeFeeBps: txArgs.standardUnstakeFeeBps ?? null,
       targetLockupDurationSecs: txArgs.targetLockupDurationSecs === void 0 ? null : new import_core11.BN(txArgs.targetLockupDurationSecs.toString()),
@@ -21576,21 +21785,27 @@ function settleVault(args) {
       args.grossNav,
       args.nowTs
     );
+    const trancheValueBeforeFees = args.tranche.junior.value + args.tranche.senior.value;
+    const juniorFees = settleShareClassPerformanceFee(
+      args.tranche.junior,
+      args.performanceFeeBps,
+      args.protocolFeeBps
+    );
+    const juniorFloorTopup = applyJuniorFloorTopup(
+      args.tranche,
+      regularGrossValue,
+      args.nowTs
+    );
     regularValue = settleFixedApyNav({
       currentSharePrice: args.currentSharePrice,
-      reportedNav: regularGrossValue,
+      reportedNav: regularGrossValue - juniorFloorTopup,
       nowTs: args.nowTs,
       totalSupply: args.totalSupply,
       fixedApyBps: args.fixedApyBps,
       anchorSharePrice: args.apyAnchorSharePrice,
       anchorTs: args.apyAnchorTs
     });
-    settledAccountingNav = regularValue + args.tranche.junior.value + args.tranche.senior.value;
-    const juniorFees = settleShareClassPerformanceFee(
-      args.tranche.junior,
-      args.performanceFeeBps,
-      args.protocolFeeBps
-    );
+    settledAccountingNav = regularValue + trancheValueBeforeFees + juniorFloorTopup;
     const regularFees = settleRegularPerformanceFee(
       regularValue,
       args.totalSupply,
@@ -21711,6 +21926,31 @@ function seniorEntitlement(tranche, nowTs) {
   );
   return targetValue > tranche.senior.value ? targetValue - tranche.senior.value : 0n;
 }
+function applyJuniorFloorTopup(tranche, availableRegularValue, nowTs) {
+  if (tranche.juniorApyAnchorTs <= 0n) {
+    tranche.juniorApyAnchorSharePrice = tranche.junior.sharePrice;
+    tranche.juniorApyAnchorTs = tranche.lastSettledTs > 0n ? tranche.lastSettledTs : nowTs;
+  }
+  if (tranche.juniorFloorApyBps === 0 || tranche.juniorApyAnchorSharePrice === 0n || tranche.junior.totalSupply === 0n || tranche.juniorApyAnchorTs <= 0n || nowTs <= tranche.juniorApyAnchorTs) {
+    return 0n;
+  }
+  const targetPrice = applyEffectiveApy(
+    tranche.juniorApyAnchorSharePrice,
+    tranche.juniorFloorApyBps,
+    nowTs - tranche.juniorApyAnchorTs
+  );
+  const targetValue = mulDiv2(
+    targetPrice,
+    tranche.junior.totalSupply,
+    DEFAULT_SHARE_PRICE
+  );
+  const shortfall = targetValue > tranche.junior.value ? targetValue - tranche.junior.value : 0n;
+  const topup = shortfall < availableRegularValue ? shortfall : availableRegularValue;
+  if (topup === 0n) return 0n;
+  tranche.junior.value += topup;
+  refreshShareClass(tranche.junior);
+  return topup;
+}
 function settleShareClassPerformanceFee(shareClass, performanceFeeBps, protocolFeeBps) {
   refreshShareClass(shareClass);
   const grossPrice = shareClass.sharePrice;
@@ -21931,9 +22171,12 @@ function decodeTrancheState(decoded, args, warnings, blockers) {
     junior,
     senior,
     seniorFixedApyBps: number(decoded.config.seniorFixedApyBps),
+    juniorFloorApyBps: number(decoded.config.juniorFloorApyBps),
     lastSettledTs: bigint(decoded.lastSettledTs),
     seniorApyAnchorSharePrice: bigint(decoded.seniorApyAnchorSharePrice),
-    seniorApyAnchorTs: bigint(decoded.seniorApyAnchorTs)
+    seniorApyAnchorTs: bigint(decoded.seniorApyAnchorTs),
+    juniorApyAnchorSharePrice: bigint(decoded.juniorApyAnchorSharePrice),
+    juniorApyAnchorTs: bigint(decoded.juniorApyAnchorTs)
   };
 }
 function decodeShareClass(value) {
@@ -23427,6 +23670,9 @@ var import_web328 = require("@solana/web3.js");
 var import_common50 = __toESM(require_dist());
 var import_marginfi3 = __toESM(require_dist2());
 var DEFAULT_MIN_AMOUNT_UI = 1;
+var DEFAULT_TARGET_LOCAL_BPS = 100;
+var DEFAULT_REBALANCE_BAND_BPS = 2e3;
+var BPS_DENOMINATOR3 = 10000n;
 function toRawAmount(uiAmount, decimals) {
   return BigInt(Math.floor(uiAmount * 10 ** decimals));
 }
@@ -23463,26 +23709,50 @@ function pubkeyStr(value) {
 function isZeroPubkey2(pk) {
   return !pk || /^1+$/.test(pk) || pk === "11111111111111111111111111111111";
 }
+function planRebalance(params) {
+  const { localAmount, externalAmount, targetLocalBps, rebalanceBandBps, minRaw } = params;
+  const total = localAmount + externalAmount;
+  const targetLocal = total * BigInt(Math.round(targetLocalBps)) / BPS_DENOMINATOR3;
+  const band = targetLocal * BigInt(Math.round(rebalanceBandBps)) / BPS_DENOMINATOR3;
+  const threshold = band > minRaw ? band : minRaw;
+  if (localAmount > targetLocal) {
+    const amount2 = localAmount - targetLocal;
+    if (amount2 < threshold) return null;
+    return { direction: "deposit", amount: amount2, targetLocal };
+  }
+  const shortfall = targetLocal - localAmount;
+  if (shortfall < threshold) return null;
+  const amount = shortfall < externalAmount ? shortfall : externalAmount;
+  if (amount < minRaw) return null;
+  return { direction: "withdraw", amount, targetLocal };
+}
 var ExternalLiquidityIntegrityService = class {
   constructor(client) {
     this.client = client;
   }
   /**
-   * Scan all vaults and deposit any idle local balance into configured external
-   * liquidity positions. Non-fatal per vault — errors are logged and counted.
+   * Scan all vaults and rebalance each holding toward its target local share.
+   * Non-fatal per vault — errors are logged and counted.
    */
   async runAll(hwManager, opts = {}) {
     const log = opts.log ?? (() => {
     });
     const dryRun = opts.dryRun ?? false;
     const minAmountUi = opts.minAmountUi ?? DEFAULT_MIN_AMOUNT_UI;
-    if (dryRun) log("DRY RUN \u2014 deposits will be simulated, not sent");
-    log(`Minimum deposit: ${minAmountUi} token(s) (~$${minAmountUi})`);
+    const targetLocalBps = opts.targetLocalBps ?? DEFAULT_TARGET_LOCAL_BPS;
+    const rebalanceBandBps = opts.rebalanceBandBps ?? DEFAULT_REBALANCE_BAND_BPS;
+    if (dryRun) log("DRY RUN \u2014 rebalances will be simulated, not sent");
+    log(`Minimum rebalance: ${minAmountUi} token(s) (~$${minAmountUi})`);
+    log(`Target local share: ${targetLocalBps / 100}% of each holding`);
+    log(
+      `Rebalance band: ${rebalanceBandBps / 100}% of target (${targetLocalBps * (1 - rebalanceBandBps / 1e4) / 100}%\u2013${targetLocalBps * (1 + rebalanceBandBps / 1e4) / 100}% of holding)`
+    );
     const allVaults = await this.client.account.fetchAllVaults({ fresh: true });
     log(`Discovered ${allVaults.length} vault(s) on-chain`);
     const summary = {
       vaultsProcessed: 0,
       totalDeposited: 0,
+      totalWithdrawn: 0,
       totalSkipped: 0,
       totalFailed: 0,
       dryRun
@@ -23493,25 +23763,29 @@ var ExternalLiquidityIntegrityService = class {
         vaultState,
         hwManager,
         log,
-        { dryRun, minAmountUi }
+        { dryRun, minAmountUi, targetLocalBps, rebalanceBandBps }
       );
       summary.vaultsProcessed++;
       summary.totalDeposited += result.deposited;
+      summary.totalWithdrawn += result.withdrawn;
       summary.totalSkipped += result.skipped;
       summary.totalFailed += result.failed;
     }
     return summary;
   }
   /**
-   * Process a single vault: for each active external liquidity slot, deposit
-   * any holdings that have a non-zero local_amount.
+   * Process a single vault: for each active external liquidity slot, move each
+   * holding's balance toward the target local/external split.
    */
   async processVault(vault, vaultState, hwManager, log, opts = {}) {
     const dryRun = opts.dryRun ?? false;
     const minAmountUi = opts.minAmountUi ?? DEFAULT_MIN_AMOUNT_UI;
+    const targetLocalBps = opts.targetLocalBps ?? DEFAULT_TARGET_LOCAL_BPS;
+    const rebalanceBandBps = opts.rebalanceBandBps ?? DEFAULT_REBALANCE_BAND_BPS;
     const result = {
       vault,
       deposited: 0,
+      withdrawn: 0,
       skipped: 0,
       failed: 0,
       signatures: []
@@ -23541,24 +23815,33 @@ var ExternalLiquidityIntegrityService = class {
       }
       const holdings = vaultState.holdings.filter((h) => {
         const mint = pubkeyStr(h.mint);
-        return !isZeroPubkey2(mint) && toBigInt3(h.localAmount) > 0n;
+        if (isZeroPubkey2(mint)) return false;
+        return toBigInt3(h.localAmount) > 0n || toBigInt3(h.externalAmount) > 0n;
       });
       if (holdings.length === 0) {
-        log(`Vault ${vault} slot ${slot.index}: no local balance to deploy`);
+        log(`Vault ${vault} slot ${slot.index}: no balance to rebalance`);
         result.skipped++;
         continue;
       }
       for (const holding of holdings) {
         const mintAddress = (0, import_kit15.address)(pubkeyStr(holding.mint));
         const localAmount = toBigInt3(holding.localAmount);
+        const externalAmount = toBigInt3(holding.externalAmount);
         const decimals = Number(holding.decimals ?? 0);
         const minRaw = toRawAmount(minAmountUi, decimals);
-        if (localAmount < minRaw) {
+        const plan = planRebalance({
+          localAmount,
+          externalAmount,
+          targetLocalBps,
+          rebalanceBandBps,
+          minRaw
+        });
+        if (!plan) {
           log(
-            `Vault ${vault} slot ${slot.index}: mint ${mintAddress} has ${formatUi(
-              localAmount,
+            `Vault ${vault} slot ${slot.index}: mint ${mintAddress} within band (local ${formatUi(localAmount, decimals)}, external ${formatUi(
+              externalAmount,
               decimals
-            )} < minimum ${minAmountUi} \u2014 skipping`
+            )}) \u2014 skipping`
           );
           result.skipped++;
           continue;
@@ -23572,31 +23855,36 @@ var ExternalLiquidityIntegrityService = class {
           continue;
         }
         log(
-          `Vault ${vault} slot ${slot.index}: ${dryRun ? "simulating deposit of" : "depositing"} ${localAmount} of mint ${mintAddress} into marginfi`
+          `Vault ${vault} slot ${slot.index}: ${dryRun ? "simulating " : ""}${plan.direction} of ${formatUi(plan.amount, decimals)} ${mintAddress} (local ${formatUi(localAmount, decimals)} \u2192 target ${formatUi(
+            plan.targetLocal,
+            decimals
+          )})`
         );
         try {
-          const outcome = await this.depositIntoMarginfi({
+          const outcome = await this.rebalanceMarginfi({
             vault,
             vaultPk,
             hwManager,
             hwManagerAddress,
             slot,
             mintAddress,
-            amount: localAmount,
+            direction: plan.direction,
+            amount: plan.amount,
             marginfiAccounts,
             dryRun,
             log
           });
           if (outcome.signature) {
             log(
-              `Vault ${vault} slot ${slot.index}: deposit tx ${outcome.signature}`
+              `Vault ${vault} slot ${slot.index}: ${plan.direction} tx ${outcome.signature}`
             );
             result.signatures.push(outcome.signature);
           }
-          result.deposited++;
+          if (plan.direction === "deposit") result.deposited++;
+          else result.withdrawn++;
         } catch (err) {
           log(
-            `Vault ${vault} slot ${slot.index}: deposit failed \u2014 ${err.message}`
+            `Vault ${vault} slot ${slot.index}: ${plan.direction} failed \u2014 ${err.message}`
           );
           result.failed++;
         }
@@ -23604,48 +23892,60 @@ var ExternalLiquidityIntegrityService = class {
     }
     return result;
   }
-  async depositIntoMarginfi(params) {
+  /**
+   * Move `amount` of `mintAddress` between the vault's own token account and
+   * its Marginfi position, in `direction`, through `protocol_interaction`.
+   */
+  async rebalanceMarginfi(params) {
     const {
       vault,
       hwManager,
       hwManagerAddress,
       slot,
       mintAddress,
+      direction,
       amount,
       marginfiAccounts,
       dryRun = false,
       log = () => {
       }
     } = params;
-    const marginfiClient = new import_marginfi3.CpiClient();
+    const marginfiClient = new import_marginfi3.CpiClient({
+      accounts: marginfiAccounts
+    });
     const { getAtaAddress: getAtaAddress16 } = await Promise.resolve().then(() => __toESM(require_dist()));
-    const signerTokenAccount = getAtaAddress16(
+    const vaultAta = getAtaAddress16(
       mintAddress,
       vault,
       marginfiAccounts.tokenProgram,
       true
     );
-    const depositRefs = (0, import_common50.createCpiRefs)([
-      marginfiClient.deposit_cpi({
+    const cpiRefs = (0, import_common50.createCpiRefs)([
+      direction === "deposit" ? marginfiClient.deposit_cpi({
         marginfiAccount: slot.userAccount,
         authority: vault,
-        signerTokenAccount,
+        signerTokenAccount: vaultAta,
+        amount
+      }) : marginfiClient.withdraw_cpi({
+        marginfiAccount: slot.userAccount,
+        authority: vault,
+        destinationTokenAccount: vaultAta,
         amount
       })
     ]);
     const ix = await this.client.tx.protocolInteraction.getIx({
       hwManager: hwManagerAddress,
       vault,
-      refs: depositRefs.refs,
+      refs: cpiRefs.refs,
       externalLiquidityIndex: slot.index,
       affectedAssetMint: mintAddress,
-      affectedVaultAta: signerTokenAccount,
+      affectedVaultAta: vaultAta,
       affectedTokenProgram: marginfiAccounts.tokenProgram,
-      accounts: depositRefs.accounts
+      accounts: cpiRefs.accounts
     });
     const plan = {
       instructions: [ix],
-      ...depositRefs.lookupTables?.length ? { lookupTables: depositRefs.lookupTables } : {}
+      ...cpiRefs.lookupTables?.length ? { lookupTables: cpiRefs.lookupTables } : {}
     };
     if (dryRun) {
       const sim = await this.client.simulateTransaction(hwManager, plan);
@@ -23653,9 +23953,7 @@ var ExternalLiquidityIntegrityService = class {
         log(`  | ${line}`);
       }
       if (sim.err) {
-        throw new Error(
-          `simulation failed: ${JSON.stringify(sim.err)}`
-        );
+        throw new Error(`simulation failed: ${JSON.stringify(sim.err)}`);
       }
       log(
         `Vault ${vault} slot ${slot.index}: simulation OK (${sim.unitsConsumed ?? "?"} CU)`
@@ -23665,9 +23963,408 @@ var ExternalLiquidityIntegrityService = class {
     return { signature: await this.client.sendTransaction(hwManager, plan) };
   }
 };
+
+// src/services/idleLiquidityService.ts
+var import_kit16 = require("@solana/kit");
+var import_spl_token19 = require("@solana/spl-token");
+var import_web329 = require("@solana/web3.js");
+var import_common51 = __toESM(require_dist());
+var import_jupiter3 = __toESM(require_dist3());
+var IDLE_RESERVE_FLOOR_BPS = 400;
+var IDLE_RESERVE_TARGET_BPS = 500;
+var DEFAULT_SLIPPAGE_BPS = 30;
+var DEFAULT_CU_PRICE_MICRO_LAMPORTS = 1e4;
+var DEFAULT_MAX_ACCOUNTS = 20;
+var COMPUTE_UNIT_LIMIT = 12e5;
+var ASSET_REBALANCE_COOLDOWN_SECS = 60;
+function toBigInt4(value) {
+  if (typeof value === "bigint") return value;
+  if (value !== null && value !== void 0) return BigInt(String(value));
+  return 0n;
+}
+function pubkeyStr2(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value.toBase58 === "function") {
+    return value.toBase58();
+  }
+  return String(value);
+}
+function coerceBool4(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const inner = value?.[0];
+  if (typeof inner === "number") return inner !== 0;
+  return false;
+}
+function formatUi2(raw, decimals) {
+  return (Number(raw) / 10 ** decimals).toFixed(Math.min(decimals, 6));
+}
+function readHolding(raw) {
+  const h = raw;
+  return {
+    mint: pubkeyStr2(h.mint),
+    price: toBigInt4(h.price),
+    decimals: Number(h.decimals ?? 0),
+    localAmount: toBigInt4(h.localAmount),
+    externalAmount: toBigInt4(h.externalAmount),
+    lastUpdateTs: Number(toBigInt4(h.lastUpdateTs)),
+    lastRebalanceTs: Number(toBigInt4(h.lastRebalanceTs))
+  };
+}
+function findHolding2(vaultState, mint) {
+  const holdings = vaultState.holdings ?? [];
+  return holdings.map(readHolding).find((h) => h.mint === mint);
+}
+function holdingValue2(holding, amount) {
+  return amount * holding.price / 10n ** BigInt(holding.decimals);
+}
+var IdleLiquidityService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Current unix time in seconds (override in tests). */
+  now() {
+    return Math.floor(Date.now() / 1e3);
+  }
+  /**
+   * Top up the vault's idle USDC reserve if it has fallen below the floor.
+   * Never throws for an expected no-op — inspect `status` on the result.
+   */
+  async run(vault, hwManager, opts = {}) {
+    const log = opts.log ?? (() => {
+    });
+    const vaultState = await this.client.account.fetchVault(vault, {
+      fresh: true
+    });
+    const registeredHwManager = pubkeyStr2(
+      vaultState.roles.hwManager
+    );
+    if (registeredHwManager !== hwManager.publicKey.toBase58()) {
+      throw new Error(
+        `Signer ${hwManager.publicKey.toBase58()} is not the vault hw_manager ${registeredHwManager}`
+      );
+    }
+    const assessment = this.assess(vault, vaultState, log);
+    if (assessment.result) return assessment.result;
+    const { usdc, pst, base } = assessment;
+    const pstInput = this.sizePstInput(base.shortfallUsdc, usdc, pst);
+    if (pstInput === 0n) {
+      const reason = "top-up rounds to zero PST";
+      return { ...base, status: "above-floor", reason };
+    }
+    const cap = opts.maxPstInput !== void 0 && opts.maxPstInput < pst.localAmount ? opts.maxPstInput : pst.localAmount;
+    if (pstInput > cap) {
+      const reason = `top-up needs ${formatUi2(
+        pstInput,
+        pst.decimals
+      )} PST but only ${formatUi2(cap, pst.decimals)} is available`;
+      log(`Vault ${vault}: ${reason} \u2014 skipping`);
+      return { ...base, status: "insufficient-pst", reason };
+    }
+    const jupiter = new import_jupiter3.JupiterSwapClient(
+      (0, import_kit16.createSolanaRpc)(this.client.provider.connection.rpcEndpoint)
+    );
+    let quote;
+    try {
+      quote = await jupiter.getQuote({
+        inputMint: import_common51.PST_MINT,
+        outputMint: import_common51.USDC_MINT,
+        amount: pstInput,
+        slippageBps: opts.slippageBps ?? DEFAULT_SLIPPAGE_BPS,
+        maxAccounts: DEFAULT_MAX_ACCOUNTS
+      });
+    } catch (err) {
+      log(`Vault ${vault}: Jupiter quote failed \u2014 ${err.message}`);
+      return { ...base, status: "failed", reason: err.message };
+    }
+    log(
+      `Vault ${vault}: swapping ${formatUi2(
+        quote.inputAmount,
+        pst.decimals
+      )} PST -> ${formatUi2(
+        quote.outputAmount,
+        usdc.decimals
+      )} USDC (price impact ${quote.priceImpactPct})`
+    );
+    try {
+      const outcome = await this.executeSwap({
+        vault,
+        vaultState,
+        hwManager,
+        jupiter,
+        quote,
+        cuPriceMicroLamports: opts.cuPriceMicroLamports ?? DEFAULT_CU_PRICE_MICRO_LAMPORTS,
+        dryRun: opts.dryRun ?? false,
+        log
+      });
+      return {
+        ...base,
+        status: outcome.signature ? "swapped" : "simulated",
+        reason: outcome.signature ? `swapped in ${outcome.signature}` : "dry run \u2014 simulation succeeded, nothing submitted",
+        pstSpent: quote.inputAmount,
+        usdcReceived: quote.outputAmount,
+        ...outcome.signature ? { signature: outcome.signature } : {}
+      };
+    } catch (err) {
+      log(`Vault ${vault}: swap failed \u2014 ${err.message}`);
+      return { ...base, status: "failed", reason: err.message };
+    }
+  }
+  // ── Assessment ──────────────────────────────────────────────────────────
+  /**
+   * Decide whether a top-up is warranted. Returns either a terminal `result`
+   * (nothing to do) or the holdings and sizing needed to build the swap.
+   */
+  assess(vault, vaultState, log) {
+    const tvl = toBigInt4(
+      vaultState.accounting?.tvl
+    );
+    const empty = {
+      vault,
+      tvl,
+      idleValue: 0n,
+      idleBps: 0,
+      shortfallUsdc: 0n,
+      pstSpent: 0n,
+      usdcReceived: 0n
+    };
+    if (tvl === 0n) {
+      const reason = "vault TVL is zero";
+      log(`Vault ${vault}: ${reason} \u2014 skipping`);
+      return { result: { ...empty, status: "no-tvl", reason } };
+    }
+    const usdc = findHolding2(vaultState, import_common51.USDC_MINT);
+    const pst = findHolding2(vaultState, import_common51.PST_MINT);
+    if (!usdc || !pst) {
+      const reason = `vault has no ${usdc ? "PST" : "USDC"} holding`;
+      log(`Vault ${vault}: ${reason} \u2014 skipping`);
+      return { result: { ...empty, status: "missing-holding", reason } };
+    }
+    const stalenessThreshold = this.stalenessThresholdSecs(vaultState);
+    const now = this.now();
+    for (const [name, holding] of [
+      ["USDC", usdc],
+      ["PST", pst]
+    ]) {
+      if (holding.price === 0n) {
+        const reason = `${name} holding has no price set`;
+        log(`Vault ${vault}: ${reason} \u2014 skipping`);
+        return { result: { ...empty, status: "stale-price", reason } };
+      }
+      if (now - holding.lastUpdateTs > stalenessThreshold) {
+        const reason = `${name} holding price is stale (last update ${holding.lastUpdateTs})`;
+        log(`Vault ${vault}: ${reason} \u2014 skipping`);
+        return { result: { ...empty, status: "stale-price", reason } };
+      }
+    }
+    const idleAmount = usdc.localAmount + usdc.externalAmount;
+    const idleValue = holdingValue2(usdc, idleAmount);
+    const idleBps = Number(idleValue * 10000n / tvl);
+    const base = { ...empty, idleValue, idleBps };
+    log(
+      `Vault ${vault}: idle USDC ${formatUi2(
+        idleAmount,
+        usdc.decimals
+      )} = ${idleBps}bps of TVL (floor ${IDLE_RESERVE_FLOOR_BPS}bps, target ${IDLE_RESERVE_TARGET_BPS}bps)`
+    );
+    if (idleBps >= IDLE_RESERVE_FLOOR_BPS) {
+      const reason = `idle USDC ${idleBps}bps is at or above the ${IDLE_RESERVE_FLOOR_BPS}bps floor`;
+      return { result: { ...base, status: "above-floor", reason } };
+    }
+    for (const [name, holding] of [
+      ["USDC", usdc],
+      ["PST", pst]
+    ]) {
+      if (holding.lastRebalanceTs !== 0 && now < holding.lastRebalanceTs + ASSET_REBALANCE_COOLDOWN_SECS) {
+        const reason = `${name} holding is in its rebalance cooldown until ${holding.lastRebalanceTs + ASSET_REBALANCE_COOLDOWN_SECS}`;
+        log(`Vault ${vault}: ${reason} \u2014 skipping`);
+        return { result: { ...base, status: "rebalance-cooldown", reason } };
+      }
+    }
+    const targetValue = tvl * BigInt(IDLE_RESERVE_TARGET_BPS) / 10000n;
+    let shortfallValue = targetValue - idleValue;
+    const allowance = this.remainingRebalanceAllowance(vaultState, tvl, now);
+    if (allowance !== void 0 && allowance < shortfallValue) {
+      if (allowance === 0n) {
+        const reason = "rolling rebalance limit is exhausted for this window";
+        log(`Vault ${vault}: ${reason} \u2014 skipping`);
+        return { result: { ...base, status: "rebalance-limit", reason } };
+      }
+      log(
+        `Vault ${vault}: rolling rebalance limit caps this run at ${allowance} of ${shortfallValue} accounting units`
+      );
+      shortfallValue = allowance;
+    }
+    const shortfallUsdc = shortfallValue * 10n ** BigInt(usdc.decimals) / usdc.price;
+    if (shortfallUsdc <= 0n) {
+      const reason = "computed shortfall rounds to zero";
+      return { result: { ...base, status: "above-floor", reason } };
+    }
+    if (pst.localAmount === 0n) {
+      const reason = "vault holds no local PST";
+      log(`Vault ${vault}: ${reason} \u2014 skipping`);
+      return {
+        result: { ...base, shortfallUsdc, status: "insufficient-pst", reason }
+      };
+    }
+    return { usdc, pst, base: { ...base, shortfallUsdc } };
+  }
+  /**
+   * Value still chargeable against the vault's rolling rebalance window, in
+   * accounting units. `undefined` when the cap is disabled (unlimited).
+   */
+  remainingRebalanceAllowance(vaultState, tvl, now) {
+    const limit = vaultState.accounting?.rebalanceLimit;
+    const bps = Number(toBigInt4(limit?.windowLimitBps));
+    if (!limit || bps === 0) return void 0;
+    const windowStartTs = Number(toBigInt4(limit.windowStartTs));
+    const windowDuration = Number(toBigInt4(limit.windowDurationSeconds));
+    const consumed = windowStartTs === 0 || now >= windowStartTs + windowDuration ? 0n : toBigInt4(limit.valueInWindow);
+    const ceiling = tvl * BigInt(bps) / 10000n;
+    return ceiling > consumed ? ceiling - consumed : 0n;
+  }
+  /**
+   * PST input that buys `shortfallUsdc` at the holdings' recorded prices.
+   * Both prices share the vault's accounting unit, so this is a straight
+   * value conversion; slippage is absorbed by landing slightly under target.
+   */
+  sizePstInput(shortfallUsdc, usdc, pst) {
+    const shortfallValue = holdingValue2(usdc, shortfallUsdc);
+    return shortfallValue * 10n ** BigInt(pst.decimals) / pst.price;
+  }
+  stalenessThresholdSecs(vaultState) {
+    const configured = Number(
+      toBigInt4(
+        vaultState.config?.priceStalenessThresholdSecs
+      )
+    );
+    return configured > 0 ? configured : DEFAULT_PRICE_STALENESS_THRESHOLD_SECS;
+  }
+  // ── Execution ───────────────────────────────────────────────────────────
+  /**
+   * Token program owning a mint. Read from the chain rather than from the
+   * holding's enum so a Token-2022 mint can never be passed to the classic
+   * program (and vice versa).
+   */
+  async mintTokenProgram(mint) {
+    const account = await this.client.provider.connection.getAccountInfo(
+      new import_web329.PublicKey(mint),
+      "confirmed"
+    );
+    if (!account) throw new Error(`Mint account not found: ${mint}`);
+    if (!account.owner.equals(import_spl_token19.TOKEN_PROGRAM_ID) && !account.owner.equals(import_spl_token19.TOKEN_2022_PROGRAM_ID)) {
+      throw new Error(
+        `Unsupported token program ${account.owner.toBase58()} for mint ${mint}`
+      );
+    }
+    return (0, import_common51.fromWeb3Pk)(account.owner);
+  }
+  /**
+   * Build, simulate, and (unless `dryRun`) submit the `jupiter_swap`.
+   *
+   * Built as a versioned transaction here rather than through
+   * `client.sendTransaction`, because a Jupiter route needs address lookup
+   * tables and a raised compute-unit limit to fit.
+   */
+  async executeSwap(params) {
+    const {
+      vault,
+      vaultState,
+      hwManager,
+      jupiter,
+      quote,
+      cuPriceMicroLamports,
+      dryRun,
+      log
+    } = params;
+    const signer = (0, import_common51.fromWeb3Pk)(hwManager.publicKey);
+    const [sourceTokenProgram, destinationTokenProgram] = await Promise.all([
+      this.mintTokenProgram(import_common51.PST_MINT),
+      this.mintTokenProgram(import_common51.USDC_MINT)
+    ]);
+    const jupiterCpi = await jupiter.getSwapCpiData(quote, vault, {
+      payer: signer
+    });
+    const { accounts: accounts2, refs, lookupTables } = (0, import_common51.createCpiRefs)([jupiterCpi]);
+    const vaultTrancheState = coerceBool4(
+      vaultState.tranchingEnabled
+    ) ? (await this.client.pda.deriveVaultTrancheStatePda(vault))[0] : void 0;
+    const plan = await this.client.tx.jupiterSwap.getTx({
+      hwManager: signer,
+      vault,
+      sourceMint: import_common51.PST_MINT,
+      destinationMint: import_common51.USDC_MINT,
+      refs,
+      accounts: accounts2,
+      sourceTokenProgram,
+      destinationTokenProgram,
+      vaultTrancheState,
+      lookupTables
+    });
+    const connection = this.client.provider.connection;
+    const instructions2 = [
+      import_web329.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNIT_LIMIT }),
+      ...cuPriceMicroLamports > 0 ? [
+        import_web329.ComputeBudgetProgram.setComputeUnitPrice({
+          microLamports: cuPriceMicroLamports
+        })
+      ] : [],
+      ...(jupiterCpi.preInstructions ?? []).map(import_common51.fromKitInstruction),
+      ...plan.instructions.map(import_common51.fromKitInstruction)
+    ];
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+    const lookupTableAccounts = await (0, import_common51.fetchLookupTables)(
+      connection,
+      plan.lookupTables ?? []
+    );
+    const message2 = new import_web329.TransactionMessage({
+      payerKey: hwManager.publicKey,
+      recentBlockhash: blockhash,
+      instructions: instructions2
+    }).compileToV0Message(lookupTableAccounts);
+    const transaction = new import_web329.VersionedTransaction(message2);
+    transaction.sign([hwManager]);
+    const simulation = await connection.simulateTransaction(transaction, {
+      sigVerify: true,
+      commitment: "confirmed"
+    });
+    if (simulation.value.err) {
+      for (const line of simulation.value.logs ?? []) log(`  | ${line}`);
+      throw new Error(
+        `simulation failed: ${JSON.stringify(simulation.value.err)}`
+      );
+    }
+    log(
+      `Vault ${vault}: simulation OK (${simulation.value.unitsConsumed ?? "?"} CU)`
+    );
+    if (dryRun) {
+      log(`Vault ${vault}: dry run \u2014 transaction NOT submitted`);
+      return {};
+    }
+    const signature = await connection.sendRawTransaction(
+      transaction.serialize(),
+      { skipPreflight: false, maxRetries: 5 }
+    );
+    const confirmation = await connection.confirmTransaction(
+      { signature, blockhash, lastValidBlockHeight },
+      "confirmed"
+    );
+    if (confirmation.value.err) {
+      throw new Error(
+        `transaction ${signature} failed: ${JSON.stringify(
+          confirmation.value.err
+        )}`
+      );
+    }
+    this.client.applyCacheInvalidations(plan);
+    log(`Vault ${vault}: swap tx ${signature}`);
+    return { signature };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ASSET_DECIMALS,
+  ASSET_REBALANCE_COOLDOWN_SECS,
   AccountClient,
   ActivateCircuitBreakerBuilder,
   CONSENSUS_ORACLE_VARIANT,
@@ -23678,15 +24375,20 @@ var ExternalLiquidityIntegrityService = class {
   CreateAssetHoldingBuilder,
   CreateTrancheStateBuilder,
   CreateVaultBuilder,
+  DEFAULT_CU_PRICE_MICRO_LAMPORTS,
   DEFAULT_JUNIOR_EARLY_UNSTAKE_FEE_BPS,
   DEFAULT_JUNIOR_STANDARD_UNSTAKE_FEE_BPS,
   DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS,
   DEFAULT_MAX_ACCEPTABLE_APY_BPS,
+  DEFAULT_MAX_ACCOUNTS,
   DEFAULT_MIN_AMOUNT_UI,
   DEFAULT_ORACLE_STALENESS_THRESHOLD_SECS,
   DEFAULT_PRICE_ORACLE_ACCOUNT,
   DEFAULT_PRICE_STALENESS_SECS,
   DEFAULT_PRICE_STALENESS_THRESHOLD_SECS,
+  DEFAULT_REBALANCE_BAND_BPS,
+  DEFAULT_SLIPPAGE_BPS,
+  DEFAULT_TARGET_LOCAL_BPS,
   DEFAULT_VAULT_ID,
   DisableCircuitBreakerBuilder,
   EXTERNAL_POSITION_SAMPLES,
@@ -23700,6 +24402,9 @@ var ExternalLiquidityIntegrityService = class {
   FEE_VAULT_CACHE_CATEGORY,
   FulfillJuniorTrancheWithdrawBuilder,
   IDL,
+  IDLE_RESERVE_FLOOR_BPS,
+  IDLE_RESERVE_TARGET_BPS,
+  IdleLiquidityService,
   InitializeVaultRolesBuilder,
   JupiterBalanceSource,
   JupiterPriceSource,
@@ -23813,6 +24518,7 @@ var ExternalLiquidityIntegrityService = class {
   mintTokensTo,
   mostFrequent,
   parseExternalLiquidityRefs,
+  planRebalance,
   prepareVaultTransaction,
   priceInAccountingUnit,
   readI64LE,