@perena/vault-sdk 1.0.65 → 1.0.67

package/dist/index.js

@@ -156,7 +156,7 @@ var require_compat = __commonJS({
     exports2.fromWeb3PublicKey = fromWeb3PublicKey;
     exports2.toWeb3PublicKey = toWeb3PublicKey;
     exports2.asWeb3PublicKey = asWeb3PublicKey2;
-    exports2.toKitInstruction = toKitInstruction41;
+    exports2.toKitInstruction = toKitInstruction43;
     exports2.fromKitInstruction = fromKitInstruction3;
     var kit_1 = require("@solana/kit");
     var web3_js_1 = require("@solana/web3.js");
@@ -172,7 +172,7 @@ var require_compat = __commonJS({
     exports2.toAddress = fromWeb3PublicKey;
     exports2.fromWeb3Pk = fromWeb3PublicKey;
     exports2.toWeb3Pk = toWeb3PublicKey;
-    function toKitInstruction41(ix) {
+    function toKitInstruction43(ix) {
       return {
         programAddress: ix.programId.toBase58(),
         data: new Uint8Array(ix.data),
@@ -201,10 +201,10 @@ var require_ata = __commonJS({
   "../common/dist/utils/accounts/ata.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getAtaAddress = getAtaAddress24;
+    exports2.getAtaAddress = getAtaAddress26;
     var spl_token_1 = require("@solana/spl-token");
     var compat_1 = require_compat();
-    function getAtaAddress24(mint, owner, tokenProgram, allowOwnerOffCurve = true) {
+    function getAtaAddress26(mint, owner, tokenProgram, allowOwnerOffCurve = true) {
       const ata = (0, spl_token_1.getAssociatedTokenAddressSync)((0, compat_1.toWeb3PublicKey)(mint), (0, compat_1.toWeb3PublicKey)(owner), allowOwnerOffCurve, (0, compat_1.toWeb3PublicKey)(tokenProgram), spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
       return ata.toBase58();
     }
@@ -2073,7 +2073,7 @@ __export(index_exports, {
   DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS: () => DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS,
   DEFAULT_MARGINFI_WEIGHT_BPS: () => DEFAULT_MARGINFI_WEIGHT_BPS,
   DEFAULT_MAX_ACCEPTABLE_APY_BPS: () => DEFAULT_MAX_ACCEPTABLE_APY_BPS,
-  DEFAULT_MINTS: () => import_common68.DEFAULT_MINTS,
+  DEFAULT_MINTS: () => import_common70.DEFAULT_MINTS,
   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,
@@ -2097,6 +2097,7 @@ __export(index_exports, {
   ExternalLiquidityIntegrityService: () => ExternalLiquidityIntegrityService,
   ExternalPositionRegistry: () => ExternalPositionRegistry,
   FEE_VAULT_CACHE_CATEGORY: () => FEE_VAULT_CACHE_CATEGORY,
+  FulfillAsyncWithdrawBuilder: () => FulfillAsyncWithdrawBuilder,
   FulfillJuniorTrancheWithdrawBuilder: () => FulfillJuniorTrancheWithdrawBuilder,
   IDL: () => IDL,
   IDLE_RESERVE_FLOOR_BPS: () => IDLE_RESERVE_FLOOR_BPS,
@@ -2128,7 +2129,7 @@ __export(index_exports, {
   ManagerRedepositAssetBuilder: () => ManagerRedepositAssetBuilder,
   ManagerWithdrawAssetBuilder: () => ManagerWithdrawAssetBuilder,
   MarginfiPositionProvider: () => MarginfiPositionProvider,
-  MintRegistry: () => import_common68.MintRegistry,
+  MintRegistry: () => import_common70.MintRegistry,
   MockYieldTracker: () => MockYieldTracker,
   NEST_API_BASE_URL: () => import_nest2.NEST_API_BASE_URL,
   NEST_RWA_SHARE_MINT: () => NEST_RWA_SHARE_MINT,
@@ -2151,6 +2152,7 @@ __export(index_exports, {
   REPORTABLE_ORACLE_VARIANTS: () => REPORTABLE_ORACLE_VARIANTS,
   RemoveAssetHoldingBuilder: () => RemoveAssetHoldingBuilder,
   ReportIncentiveV3Builder: () => ReportIncentiveV3Builder,
+  RequestAsyncWithdrawBuilder: () => RequestAsyncWithdrawBuilder,
   RequestJuniorTrancheWithdrawBuilder: () => RequestJuniorTrancheWithdrawBuilder,
   RpcManagerWalletBalanceSource: () => RpcManagerWalletBalanceSource,
   RpcMpcWalletBalanceSource: () => RpcMpcWalletBalanceSource,
@@ -2195,6 +2197,7 @@ __export(index_exports, {
   VaultLutManager: () => VaultLutManager,
   VaultQuoteClient: () => VaultQuoteClient,
   VaultReallocationBuilder: () => VaultReallocationBuilder,
+  WALLET_FEE_EXEMPT_WHITELIST: () => WALLET_FEE_EXEMPT_WHITELIST,
   WITHDRAWABLE_RESERVE_FLOOR_BPS: () => WITHDRAWABLE_RESERVE_FLOOR_BPS,
   WithdrawalQueueService: () => WithdrawalQueueService,
   accountingUnitPriceToUsd: () => accountingUnitPriceToUsd,
@@ -2281,7 +2284,7 @@ __export(index_exports, {
   makeProvider: () => makeProvider,
   managerReconciliationStateKey: () => managerReconciliationStateKey,
   mintTokensTo: () => mintTokensTo,
-  mints: () => import_common68.mints,
+  mints: () => import_common70.mints,
   mostFrequent: () => mostFrequent,
   parseExternalLiquidityRefs: () => parseExternalLiquidityRefs,
   planExternalAllocation: () => planExternalAllocation,
@@ -2293,6 +2296,7 @@ __export(index_exports, {
   previousPhysicalNav: () => previousPhysicalNav,
   priceInAccountingUnit: () => priceInAccountingUnit,
   publishedConsensusBlockers: () => publishedConsensusBlockers,
+  quoteWithdrawalPayout: () => quoteWithdrawalPayout,
   readI64LE: () => readI64LE,
   readSplMintSupply: () => readSplMintSupply,
   reconcileManagerWalletBalances: () => reconcileManagerWalletBalances,
@@ -2355,6 +2359,9 @@ var PROGRAM_FEE_EXEMPT_OWNER_WHITELIST = [
   (0, import_kit.address)("soBBAHNhFyWF4QBCK9BJLVkX6d6NZt37ozNaPV5aq3H"),
   (0, import_kit.address)("GooseA4bSoxitTMPa4ppe2zUQ9fu4139u8pEk6x65SR")
 ];
+var WALLET_FEE_EXEMPT_WHITELIST = [
+  (0, import_kit.address)("He4ka5Q3N1UvZikZvykdi47xyk5PoVP2tcQL5sVp31Sz")
+];
 var VAULT_CREATOR_WHITELIST = [
   (0, import_kit.address)("4jMRBkpWrfhhwFYTwG3o7hmsXQwbJUwdyUX8htB6KwLJ"),
   (0, import_kit.address)("4YrMcKqx6CYpHJs7Bp8eMKLpRzZRRhKyFMoBmoPvGKM1")
@@ -2428,16 +2435,16 @@ function withVaultLookupTables(plan, programId, overrides) {
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
-var import_core22 = require("@anchor-lang/core");
-var import_web328 = require("@solana/web3.js");
+var import_core23 = require("@anchor-lang/core");
+var import_web330 = require("@solana/web3.js");
 var import_kit11 = require("@solana/kit");
-var import_common47 = __toESM(require_dist());
+var import_common49 = __toESM(require_dist());
 
 // src/client/client.ts
-var import_core21 = require("@anchor-lang/core");
+var import_core22 = require("@anchor-lang/core");
 var import_kit10 = require("@solana/kit");
-var import_web327 = require("@solana/web3.js");
-var import_common46 = __toESM(require_dist());
+var import_web329 = require("@solana/web3.js");
+var import_common48 = __toESM(require_dist());
 
 // src/idl/vault.ts
 var IDL = {
@@ -7341,6 +7348,262 @@ var IDL = {
         }
       ]
     },
+    {
+      "name": "fulfill_async_withdraw",
+      "discriminator": [
+        115,
+        156,
+        99,
+        78,
+        105,
+        35,
+        212,
+        150
+      ],
+      "accounts": [
+        {
+          "name": "signer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "owner"
+        },
+        {
+          "name": "queue_payer",
+          "writable": true
+        },
+        {
+          "name": "vault",
+          "writable": true
+        },
+        {
+          "name": "vault_oracle"
+        },
+        {
+          "name": "vault_tranche_state",
+          "optional": true
+        },
+        {
+          "name": "withdrawal_queue",
+          "writable": true
+        },
+        {
+          "name": "output_mint"
+        },
+        {
+          "name": "input_mint",
+          "writable": true
+        },
+        {
+          "name": "owner_input_ata",
+          "writable": true
+        },
+        {
+          "name": "owner_output_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "owner"
+              },
+              {
+                "kind": "account",
+                "path": "asset_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "output_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": "vault_output_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "vault"
+              },
+              {
+                "kind": "account",
+                "path": "asset_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "output_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": "queue_input_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "withdrawal_queue"
+              },
+              {
+                "kind": "account",
+                "path": "share_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "input_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": "asset_token_program"
+        },
+        {
+          "name": "share_token_program"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "external_withdraw_ix_refs",
+          "type": {
+            "option": {
+              "defined": {
+                "name": "InstructionRefs"
+              }
+            }
+          }
+        },
+        {
+          "name": "external_liquidity_source",
+          "type": {
+            "option": "u8"
+          }
+        }
+      ]
+    },
     {
       "name": "fulfill_junior_tranche_withdraw",
       "discriminator": [
@@ -8607,6 +8870,129 @@ var IDL = {
         }
       ]
     },
+    {
+      "name": "request_async_withdraw",
+      "discriminator": [
+        90,
+        83,
+        61,
+        227,
+        146,
+        51,
+        252,
+        225
+      ],
+      "accounts": [
+        {
+          "name": "user",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "vault"
+        },
+        {
+          "name": "vault_oracle"
+        },
+        {
+          "name": "withdrawal_queue",
+          "writable": true
+        },
+        {
+          "name": "output_mint"
+        },
+        {
+          "name": "input_mint"
+        },
+        {
+          "name": "user_input_ata",
+          "writable": true
+        },
+        {
+          "name": "queue_input_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "withdrawal_queue"
+              },
+              {
+                "kind": "account",
+                "path": "share_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "input_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": "share_token_program"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "queue_id",
+          "type": "u8"
+        },
+        {
+          "name": "share_amount",
+          "type": "u64"
+        }
+      ]
+    },
     {
       "name": "request_junior_tranche_withdraw",
       "discriminator": [
@@ -11123,6 +11509,26 @@ var IDL = {
         ]
       }
     },
+    {
+      "name": "RedemptionMode",
+      "docs": [
+        "Redemption policy for regular vault shares. Zero preserves existing vault behavior."
+      ],
+      "repr": {
+        "kind": "rust"
+      },
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Synchronous"
+          },
+          {
+            "name": "AsyncOnly"
+          }
+        ]
+      }
+    },
     {
       "name": "ReportIncentiveV3Args",
       "type": {
@@ -11582,6 +11988,19 @@ var IDL = {
                 }
               }
             }
+          },
+          {
+            "name": "redemption_mode",
+            "docs": [
+              "Regular-share redemption policy. None leaves unchanged."
+            ],
+            "type": {
+              "option": {
+                "defined": {
+                  "name": "RedemptionMode"
+                }
+              }
+            }
           }
         ]
       }
@@ -11834,13 +12253,13 @@ var IDL = {
             }
           },
           {
-            "name": "_padding_bool",
+            "name": "redemption_mode",
             "docs": [
-              "Reserved byte retained for on-chain account layout compatibility."
+              "Regular-share redemption policy; occupies the former zeroed padding byte."
             ],
             "type": {
               "defined": {
-                "name": "PodBool"
+                "name": "RedemptionMode"
               }
             }
           },
@@ -12931,7 +13350,7 @@ var IDL = {
           {
             "name": "fulfiller",
             "docs": [
-              "Hot wallet authorised to fulfill expired junior withdrawal queues."
+              "Hot wallet authorised to fulfill regular and expired junior withdrawal queues."
             ],
             "type": "pubkey"
           },
@@ -13603,6 +14022,13 @@ var AccountClient = class extends import_common.BaseAccountClient {
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(vault);
     return this.fetchVaultOracle(vaultOracle, opts);
   }
+  /** Fresh discovery read: only an absent oracle returns null; RPC errors propagate. */
+  async fetchVaultOracleForVaultNullable(vault) {
+    const [vaultOracle] = await this.pda.deriveVaultOraclePda(vault);
+    return this.program.account.vaultOracle.fetchNullable(
+      (0, import_common.toWeb3Pk)(vaultOracle)
+    );
+  }
   async fetchVaultTrancheState(vaultTrancheState, opts) {
     if (opts?.fresh) {
       this.dataCache.clearCacheEntry(
@@ -13625,6 +14051,32 @@ var AccountClient = class extends import_common.BaseAccountClient {
     );
     return this.fetchVaultTrancheState(vaultTrancheState, opts);
   }
+  /** Shared queue fetcher, for either regular or junior shares. */
+  async fetchVaultWithdrawalQueue(withdrawalQueue, opts) {
+    return this.fetchVaultTrancheWithdrawalQueue(withdrawalQueue, opts);
+  }
+  /** Fresh pending requests. Fulfilled/cancelled queues are closed on chain. */
+  async fetchAllWithdrawalQueues(opts = {}) {
+    const filters = [
+      ...opts.owner ? [{ memcmp: { offset: 16, bytes: opts.owner } }] : [],
+      ...opts.vault ? [{ memcmp: { offset: 48, bytes: opts.vault } }] : [],
+      ...opts.inputMint ? [{ memcmp: { offset: 112, bytes: opts.inputMint } }] : []
+    ];
+    const queues = await this.program.account.vaultWithdrawalQueue.all(filters);
+    return queues.map(({ publicKey, account }) => ({
+      publicKey: (0, import_common.fromWeb3Pk)(publicKey),
+      account
+    }));
+  }
+  /** All pending regular-share redemptions for a vault, optionally restricted to an owner. */
+  async fetchPendingRedemptionQueues(vault, owner) {
+    const data = await this.fetchVault(vault, { fresh: true });
+    return this.fetchAllWithdrawalQueues({
+      vault,
+      owner,
+      inputMint: (0, import_common.fromWeb3Pk)(data.mint)
+    });
+  }
   async fetchVaultTrancheWithdrawalQueue(withdrawalQueue, opts) {
     if (opts?.fresh) {
       this.dataCache.clearCacheEntry(
@@ -13750,11 +14202,14 @@ var PdaClient = class {
     });
   }
   /**
-   * Junior tranche withdrawal queue PDA.
+   * Shared withdrawal queue PDA for regular and junior shares.
    *
    * Seeds: `["vault_withdrawal_queue", vault, owner, queue_id]`
    */
-  async deriveVaultTrancheWithdrawalQueuePda(vault, owner, queueId) {
+  async deriveVaultWithdrawalQueuePda(vault, owner, queueId) {
+    if (!Number.isInteger(queueId) || queueId < 0 || queueId > 255) {
+      throw new RangeError("Withdrawal queue ID must fit u8");
+    }
     return (0, import_kit4.getProgramDerivedAddress)({
       programAddress: this.programAddress,
       seeds: [
@@ -13765,6 +14220,10 @@ var PdaClient = class {
       ]
     });
   }
+  /** Backward-compatible alias; queue IDs are shared by both share classes. */
+  async deriveVaultTrancheWithdrawalQueuePda(vault, owner, queueId) {
+    return this.deriveVaultWithdrawalQueuePda(vault, owner, queueId);
+  }
 };
 
 // src/client/quote.ts
@@ -15119,6 +15578,7 @@ function toAnchorSetVaultConfigArgs(args) {
     maxApyBps: args.maxApyBps,
     tvlLimit: args.tvlLimit,
     lossesEnabled: args.lossesEnabled,
+    redemptionMode: args.redemptionMode ?? null,
     priceStalenessThresholdSecs: args.priceStalenessThresholdSecs,
     userBurnLimit: args.userBurnLimit,
     managerPullLimit: args.managerPullLimit,
@@ -15317,6 +15777,7 @@ var SetVaultConfigBuilder = class extends VaultBuilderBase {
         maxApyBps: txArgs.maxApyBps ?? null,
         tvlLimit: txArgs.tvlLimit !== void 0 ? new import_core7.BN(txArgs.tvlLimit.toString()) : null,
         lossesEnabled: txArgs.lossesEnabled ?? null,
+        redemptionMode: txArgs.redemptionMode ?? null,
         priceStalenessThresholdSecs: txArgs.priceStalenessThresholdSecs !== void 0 ? new import_core7.BN(txArgs.priceStalenessThresholdSecs.toString()) : null,
         userBurnLimit: txArgs.userBurnLimit !== void 0 ? {
           windowLimit: new import_core7.BN(
@@ -16632,7 +17093,7 @@ async function loadWithdrawalPosition(args) {
 }
 
 // src/client/builders/withdrawalPlan.ts
-function payout(pricing, shares) {
+function quoteWithdrawalPayout(pricing, shares) {
   const gross = shares * pricing.value / pricing.supply;
   const fee = gross * BigInt(pricing.feeBps) / 10000n;
   const feeShares = shares * BigInt(pricing.feeBps) / 10000n;
@@ -16647,11 +17108,11 @@ function payout(pricing, shares) {
 }
 function isRedeemable(pricing, shares) {
   if (shares <= 0n) return false;
-  const quote = payout(pricing, shares);
+  const quote = quoteWithdrawalPayout(pricing, shares);
   return quote.gross > 0n && (quote.net === 0n || quote.tokens > 0n) && (pricing.shareClass !== "regular" || quote.fee === 0n || quote.feeShares > 0n);
 }
 function afterBurn(pricing, shares) {
-  const quote = payout(pricing, shares);
+  const quote = quoteWithdrawalPayout(pricing, shares);
   return {
     ...pricing,
     supply: pricing.supply - (pricing.shareClass === "regular" ? shares - quote.feeShares : shares),
@@ -16662,7 +17123,7 @@ function sharesWithinCapacity(pricing, remaining, capacity) {
   let low = 0n, high = remaining;
   while (low < high) {
     const mid = (low + high + 1n) / 2n;
-    if (payout(pricing, mid).tokens <= capacity) low = mid;
+    if (quoteWithdrawalPayout(pricing, mid).tokens <= capacity) low = mid;
     else high = mid - 1n;
   }
   const maximum = low;
@@ -16686,7 +17147,7 @@ async function planWithdrawalLegs(args) {
   const pools = /* @__PURE__ */ new Map();
   const positions = /* @__PURE__ */ new Set();
   const append = (shares, position) => {
-    const quote = payout(pricing, shares);
+    const quote = quoteWithdrawalPayout(pricing, shares);
     if (!isRedeemable(pricing, shares)) return false;
     const needed = quote.tokens > local ? quote.tokens - local : 0n;
     const receipt = needed > 0n ? position.receipt(needed) : 0n;
@@ -16708,7 +17169,8 @@ async function planWithdrawalLegs(args) {
     remaining -= shares;
     return true;
   };
-  if (payout(pricing, remaining).tokens <= local) append(remaining);
+  if (quoteWithdrawalPayout(pricing, remaining).tokens <= local)
+    append(remaining);
   else {
     for await (const position of args.positions) {
       if (positions.has(position.positionKey)) continue;
@@ -16725,7 +17187,7 @@ async function planWithdrawalLegs(args) {
       if (shares > 0n) append(shares, position);
       if (remaining === 0n) break;
     }
-    if (remaining > 0n && payout(pricing, remaining).tokens <= local)
+    if (remaining > 0n && quoteWithdrawalPayout(pricing, remaining).tokens <= local)
       append(remaining);
   }
   if (remaining > 0n)
@@ -18131,116 +18593,404 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
         assetTokenProgram,
         true
       ),
-      destinationFeeVault,
-      destinationFeeVaultMintAta: (0, import_common45.getAtaAddress)(
-        txArgs.mint,
-        destinationFeeVault,
-        assetTokenProgram,
+      destinationFeeVault,
+      destinationFeeVaultMintAta: (0, import_common45.getAtaAddress)(
+        txArgs.mint,
+        destinationFeeVault,
+        assetTokenProgram,
+        true
+      ),
+      allocationSourceShareAta: sourceShareMint && sourceVault ? (0, import_common45.getAtaAddress)(
+        sourceShareMint,
+        txArgs.allocationVault,
+        sourceShareTokenProgram,
+        true
+      ) : null,
+      allocationDestinationShareAta: (0, import_common45.getAtaAddress)(
+        txArgs.destinationShareMint,
+        txArgs.allocationVault,
+        destinationShareTokenProgram,
+        true
+      )
+    };
+  }
+  async buildPreambleInstructions(args) {
+    const payer = (0, import_common45.toWeb3Pk)(args.manager);
+    const instructions2 = [
+      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+        payer,
+        (0, import_common45.toWeb3Pk)(args.allocationMintAta),
+        (0, import_common45.toWeb3Pk)(args.allocationVault),
+        (0, import_common45.toWeb3Pk)(args.mint),
+        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
+        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+      ),
+      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+        payer,
+        (0, import_common45.toWeb3Pk)(args.destinationVaultMintAta),
+        (0, import_common45.toWeb3Pk)(args.destinationVault),
+        (0, import_common45.toWeb3Pk)(args.mint),
+        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
+        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+      ),
+      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+        payer,
+        (0, import_common45.toWeb3Pk)(args.destinationFeeVaultMintAta),
+        (0, import_common45.toWeb3Pk)(args.destinationFeeVault),
+        (0, import_common45.toWeb3Pk)(args.mint),
+        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
+        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+      ),
+      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+        payer,
+        (0, import_common45.toWeb3Pk)(args.allocationDestinationShareAta),
+        (0, import_common45.toWeb3Pk)(args.allocationVault),
+        (0, import_common45.toWeb3Pk)(args.destinationShareMint),
+        (0, import_common45.toWeb3Pk)(args.destinationShareTokenProgram),
+        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+      )
+    ];
+    if (args.sourceVault && args.sourceShareMint && args.sourceVaultMintAta && args.allocationSourceShareAta) {
+      instructions2.push(
+        (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+          payer,
+          (0, import_common45.toWeb3Pk)(args.sourceVaultMintAta),
+          (0, import_common45.toWeb3Pk)(args.sourceVault),
+          (0, import_common45.toWeb3Pk)(args.mint),
+          (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
+          import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+        ),
+        (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
+          payer,
+          (0, import_common45.toWeb3Pk)(args.allocationSourceShareAta),
+          (0, import_common45.toWeb3Pk)(args.allocationVault),
+          (0, import_common45.toWeb3Pk)(args.sourceShareMint),
+          (0, import_common45.toWeb3Pk)(args.sourceShareTokenProgram),
+          import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
+        )
+      );
+    }
+    return instructions2.map(import_common45.toKitInstruction);
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        { vaultPda: args.allocationVault },
+        { vaultPda: args.destinationVault },
+        ...args.sourceVault ? [{ vaultPda: args.sourceVault }] : [],
+        ...args.sourceVault && args.sourceVaultTrancheState ? [
+          {
+            vaultPda: args.sourceVault,
+            vaultTrancheStatePda: args.sourceVaultTrancheState
+          }
+        ] : [],
+        ...args.destinationVaultTrancheState ? [
+          {
+            vaultPda: args.destinationVault,
+            vaultTrancheStatePda: args.destinationVaultTrancheState
+          }
+        ] : []
+      ]
+    };
+  }
+  async getTx(txArgs) {
+    const args = await this.deriveIxArgs(txArgs);
+    const preambleInstructions = await this.buildPreambleInstructions(args);
+    const instruction = await this.getIx(args);
+    const extras = await this.buildPlanExtras(args);
+    return this.withVaultLookupTables({
+      instructions: [...preambleInstructions, instruction],
+      ...extras
+    });
+  }
+};
+
+// src/client/builders/requestAsyncWithdraw.ts
+var import_core21 = require("@anchor-lang/core");
+var import_spl_token21 = require("@solana/spl-token");
+var import_web327 = require("@solana/web3.js");
+var import_common46 = __toESM(require_dist());
+var RequestAsyncWithdrawBuilder = class extends VaultBuilderBase {
+  async getIx(args) {
+    return this.program.methods.requestAsyncWithdraw(args.queueId, args.shareAmount).accountsPartial({
+      user: (0, import_common46.toWeb3Pk)(args.user),
+      payer: (0, import_common46.toWeb3Pk)(args.payer),
+      vault: (0, import_common46.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common46.toWeb3Pk)(args.vaultOracle),
+      withdrawalQueue: (0, import_common46.toWeb3Pk)(args.withdrawalQueue),
+      outputMint: (0, import_common46.toWeb3Pk)(args.outputMint),
+      inputMint: (0, import_common46.toWeb3Pk)(args.inputMint),
+      userInputAta: (0, import_common46.toWeb3Pk)(args.userInputAta),
+      queueInputAta: (0, import_common46.toWeb3Pk)(args.queueInputAta),
+      shareTokenProgram: (0, import_common46.toWeb3Pk)(args.shareTokenProgram),
+      associatedTokenProgram: import_spl_token21.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: import_web327.SystemProgram.programId
+    }).instruction().then(import_common46.toKitInstruction);
+  }
+  async deriveIxArgs(txArgs) {
+    const payer = txArgs.payer ?? txArgs.user;
+    const [[vaultOracle], [withdrawalQueue], shareTokenProgram, vaultData] = await Promise.all([
+      this.pda.deriveVaultOraclePda(txArgs.vault),
+      this.pda.deriveVaultWithdrawalQueuePda(
+        txArgs.vault,
+        txArgs.user,
+        txArgs.queueId
+      ),
+      resolveVaultShareTokenProgram(
+        this.account,
+        txArgs.vault,
+        txArgs.shareTokenProgram
+      ),
+      this.account.fetchVault(txArgs.vault)
+    ]);
+    const shareMint = txArgs.shareMint ?? (0, import_common46.fromWeb3Pk)(vaultData.mint);
+    const queuePda = txArgs.withdrawalQueue ?? withdrawalQueue;
+    return {
+      user: txArgs.user,
+      payer,
+      vault: txArgs.vault,
+      vaultOracle: txArgs.vaultOracle ?? vaultOracle,
+      withdrawalQueue: queuePda,
+      outputMint: txArgs.assetMint,
+      inputMint: shareMint,
+      queueId: txArgs.queueId,
+      shareAmount: new import_core21.BN(txArgs.shareAmount.toString()),
+      shareTokenProgram,
+      userInputAta: txArgs.userInputAta ?? (0, import_common46.getAtaAddress)(shareMint, txArgs.user, shareTokenProgram, true),
+      queueInputAta: (0, import_common46.getAtaAddress)(
+        shareMint,
+        queuePda,
+        shareTokenProgram,
+        true
+      )
+    };
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        {
+          vaultPda: args.vault,
+          withdrawalQueuePda: args.withdrawalQueue
+        }
+      ]
+    };
+  }
+};
+
+// src/client/builders/fulfillAsyncWithdraw.ts
+var import_spl_token22 = require("@solana/spl-token");
+var import_web328 = require("@solana/web3.js");
+var import_common47 = __toESM(require_dist());
+var FulfillAsyncWithdrawBuilder = class extends VaultBuilderBase {
+  async getIx(args) {
+    const externalWithdrawIxRefs = args.externalWithdrawIxRefs ?? null;
+    const externalLiquiditySource = args.externalLiquiditySource ?? null;
+    const methods = this.program.methods.fulfillAsyncWithdraw(
+      externalWithdrawIxRefs,
+      externalLiquiditySource
+    );
+    return methods.accountsPartial({
+      signer: (0, import_common47.toWeb3Pk)(args.signer),
+      owner: (0, import_common47.toWeb3Pk)(args.owner),
+      queuePayer: (0, import_common47.toWeb3Pk)(args.queuePayer),
+      vault: (0, import_common47.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common47.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common47.toWeb3Pk)(args.vaultTrancheState) : null,
+      withdrawalQueue: (0, import_common47.toWeb3Pk)(args.withdrawalQueue),
+      outputMint: (0, import_common47.toWeb3Pk)(args.outputMint),
+      inputMint: (0, import_common47.toWeb3Pk)(args.inputMint),
+      ownerInputAta: (0, import_common47.toWeb3Pk)(args.ownerInputAta),
+      ownerOutputAta: (0, import_common47.toWeb3Pk)(args.ownerOutputAta),
+      vaultOutputAta: (0, import_common47.toWeb3Pk)(args.vaultOutputAta),
+      queueInputAta: (0, import_common47.toWeb3Pk)(args.queueInputAta),
+      assetTokenProgram: (0, import_common47.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common47.toWeb3Pk)(args.shareTokenProgram),
+      associatedTokenProgram: import_spl_token22.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: import_web328.SystemProgram.programId
+    }).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common47.toKitInstruction);
+  }
+  async deriveIxArgs(txArgs) {
+    const connection = this.program.provider.connection;
+    const signer = txArgs.signer;
+    const [
+      [vaultOracle],
+      vaultTrancheState,
+      [withdrawalQueue],
+      assetTokenProgram,
+      shareTokenProgram,
+      vaultData
+    ] = await Promise.all([
+      this.pda.deriveVaultOraclePda(txArgs.vault),
+      resolveVaultTrancheState(
+        this.account,
+        this.pda,
+        txArgs.vault,
+        txArgs.vaultTrancheState
+      ),
+      this.pda.deriveVaultWithdrawalQueuePda(
+        txArgs.vault,
+        txArgs.owner,
+        txArgs.queueId
+      ),
+      resolveHoldingTokenProgram(
+        this.account,
+        connection,
+        txArgs.vault,
+        txArgs.assetMint,
+        txArgs.assetTokenProgram
+      ),
+      resolveVaultShareTokenProgram(
+        this.account,
+        txArgs.vault,
+        txArgs.shareTokenProgram
+      ),
+      this.account.fetchVault(txArgs.vault, { fresh: true })
+    ]);
+    const shareMint = txArgs.shareMint ?? (0, import_common47.fromWeb3Pk)(vaultData.mint);
+    const queuePda = txArgs.withdrawalQueue ?? withdrawalQueue;
+    const queue = await this.account.fetchVaultWithdrawalQueue(queuePda, {
+      fresh: true
+    });
+    const queuePayer = txArgs.queuePayer ?? (0, import_common47.fromWeb3Pk)(queue.parties.payer);
+    const vaultOutputAta = (0, import_common47.getAtaAddress)(
+      txArgs.assetMint,
+      txArgs.vault,
+      assetTokenProgram,
+      true
+    );
+    let skipExternalLiquidity = txArgs.skipExternalLiquidity ?? false;
+    if (!txArgs.externalWithdrawIxRefs && !skipExternalLiquidity) {
+      const [localAmount, tranche] = await Promise.all([
+        readTokenBalance(connection, vaultOutputAta, assetTokenProgram),
+        vaultTrancheState ? this.account.fetchVaultTrancheState(vaultTrancheState, {
+          fresh: true
+        }) : null
+      ]);
+      const holding = vaultData.holdings.find(
+        (h) => (0, import_common47.fromWeb3Pk)(h.mint) === txArgs.assetMint
+      );
+      if (!holding) throw new Error("Withdrawal asset is not a vault holding");
+      const supply = BigInt(vaultData.accounting.totalMintSupply.toString());
+      const value = BigInt(vaultData.accounting.tvl.toString()) - (tranche ? BigInt(tranche.junior.value.toString()) + BigInt(tranche.senior.value.toString()) : 0n);
+      const price = BigInt(holding.price.toString());
+      if (supply <= 0n || value < 0n || price <= 0n)
+        throw new Error("Invalid async withdrawal pricing state");
+      const quote = quoteWithdrawalPayout(
+        {
+          shareClass: "regular",
+          supply,
+          value,
+          price,
+          decimals: holding.decimals,
+          // The queue owner receives the exemption, not the fulfiller.
+          feeBps: WALLET_FEE_EXEMPT_WHITELIST.includes(
+            (0, import_common47.fromWeb3Pk)(queue.parties.owner)
+          ) ? 0 : vaultData.config.fees.burnFeeBps
+        },
+        BigInt(queue.request.inputAmount.toString())
+      );
+      skipExternalLiquidity = localAmount >= quote.tokens;
+    }
+    const {
+      externalWithdrawIxRefs,
+      externalLiquiditySource,
+      externalWithdrawAccounts
+    } = skipExternalLiquidity && !txArgs.externalWithdrawIxRefs ? {
+      externalWithdrawIxRefs: null,
+      externalLiquiditySource: null,
+      externalWithdrawAccounts: []
+    } : await resolveExternalWithdraw({
+      connection,
+      externalLiquidity: vaultData.externalLiquidity,
+      vault: txArgs.vault,
+      assetMint: txArgs.assetMint,
+      vaultAssetAta: vaultOutputAta,
+      overrides: txArgs
+    });
+    return {
+      signer,
+      owner: txArgs.owner,
+      queuePayer,
+      vault: txArgs.vault,
+      vaultOracle: txArgs.vaultOracle ?? vaultOracle,
+      vaultTrancheState: vaultTrancheState ?? null,
+      withdrawalQueue: queuePda,
+      outputMint: txArgs.assetMint,
+      inputMint: shareMint,
+      assetTokenProgram,
+      shareTokenProgram,
+      ownerInputAta: txArgs.ownerInputAta ?? (0, import_common47.getAtaAddress)(shareMint, txArgs.owner, shareTokenProgram, true),
+      ownerOutputAta: (0, import_common47.getAtaAddress)(
+        txArgs.assetMint,
+        txArgs.owner,
+        assetTokenProgram,
+        true
+      ),
+      vaultOutputAta,
+      queueInputAta: (0, import_common47.getAtaAddress)(
+        shareMint,
+        queuePda,
+        shareTokenProgram,
         true
       ),
-      allocationSourceShareAta: sourceShareMint && sourceVault ? (0, import_common45.getAtaAddress)(
-        sourceShareMint,
-        txArgs.allocationVault,
-        sourceShareTokenProgram,
-        true
-      ) : null,
-      allocationDestinationShareAta: (0, import_common45.getAtaAddress)(
-        txArgs.destinationShareMint,
-        txArgs.allocationVault,
-        destinationShareTokenProgram,
-        true
-      )
+      externalWithdrawIxRefs,
+      externalLiquiditySource,
+      externalWithdrawAccounts
     };
   }
+  async buildLookupTables(args, txArgs) {
+    return externalWithdrawLookupTables(
+      args.externalWithdrawIxRefs,
+      txArgs.lookupTables
+    );
+  }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common45.toWeb3Pk)(args.manager);
-    const instructions2 = [
-      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-        payer,
-        (0, import_common45.toWeb3Pk)(args.allocationMintAta),
-        (0, import_common45.toWeb3Pk)(args.allocationVault),
-        (0, import_common45.toWeb3Pk)(args.mint),
-        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
-        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-      ),
-      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-        payer,
-        (0, import_common45.toWeb3Pk)(args.destinationVaultMintAta),
-        (0, import_common45.toWeb3Pk)(args.destinationVault),
-        (0, import_common45.toWeb3Pk)(args.mint),
-        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
-        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-      ),
-      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-        payer,
-        (0, import_common45.toWeb3Pk)(args.destinationFeeVaultMintAta),
-        (0, import_common45.toWeb3Pk)(args.destinationFeeVault),
-        (0, import_common45.toWeb3Pk)(args.mint),
-        (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
-        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-      ),
-      (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-        payer,
-        (0, import_common45.toWeb3Pk)(args.allocationDestinationShareAta),
-        (0, import_common45.toWeb3Pk)(args.allocationVault),
-        (0, import_common45.toWeb3Pk)(args.destinationShareMint),
-        (0, import_common45.toWeb3Pk)(args.destinationShareTokenProgram),
-        import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-      )
+    const defaultOwnerInputAta = (0, import_common47.getAtaAddress)(
+      args.inputMint,
+      args.owner,
+      args.shareTokenProgram,
+      true
+    );
+    const atas = [
+      {
+        mint: args.outputMint,
+        ata: args.ownerOutputAta,
+        program: args.assetTokenProgram
+      }
     ];
-    if (args.sourceVault && args.sourceShareMint && args.sourceVaultMintAta && args.allocationSourceShareAta) {
-      instructions2.push(
-        (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-          payer,
-          (0, import_common45.toWeb3Pk)(args.sourceVaultMintAta),
-          (0, import_common45.toWeb3Pk)(args.sourceVault),
-          (0, import_common45.toWeb3Pk)(args.mint),
-          (0, import_common45.toWeb3Pk)(args.assetTokenProgram),
-          import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-        ),
-        (0, import_spl_token20.createAssociatedTokenAccountIdempotentInstruction)(
-          payer,
-          (0, import_common45.toWeb3Pk)(args.allocationSourceShareAta),
-          (0, import_common45.toWeb3Pk)(args.allocationVault),
-          (0, import_common45.toWeb3Pk)(args.sourceShareMint),
-          (0, import_common45.toWeb3Pk)(args.sourceShareTokenProgram),
-          import_spl_token20.ASSOCIATED_TOKEN_PROGRAM_ID
-        )
-      );
+    if ((0, import_common47.toWeb3Pk)(args.ownerInputAta).equals((0, import_common47.toWeb3Pk)(defaultOwnerInputAta))) {
+      atas.push({
+        mint: args.inputMint,
+        ata: args.ownerInputAta,
+        program: args.shareTokenProgram
+      });
     }
-    return instructions2.map(import_common45.toKitInstruction);
+    return [
+      ...externalWithdrawComputeBudget(args.externalWithdrawIxRefs),
+      ...atas.map(
+        ({ mint, ata, program }) => (0, import_common47.toKitInstruction)(
+          (0, import_spl_token22.createAssociatedTokenAccountIdempotentInstruction)(
+            (0, import_common47.toWeb3Pk)(args.signer),
+            (0, import_common47.toWeb3Pk)(ata),
+            (0, import_common47.toWeb3Pk)(args.owner),
+            (0, import_common47.toWeb3Pk)(mint),
+            (0, import_common47.toWeb3Pk)(program)
+          )
+        )
+      )
+    ];
   }
   async buildPlanExtras(args) {
     return {
       postSuccessCacheInvalidations: [
-        { vaultPda: args.allocationVault },
-        { vaultPda: args.destinationVault },
-        ...args.sourceVault ? [{ vaultPda: args.sourceVault }] : [],
-        ...args.sourceVault && args.sourceVaultTrancheState ? [
-          {
-            vaultPda: args.sourceVault,
-            vaultTrancheStatePda: args.sourceVaultTrancheState
-          }
-        ] : [],
-        ...args.destinationVaultTrancheState ? [
-          {
-            vaultPda: args.destinationVault,
-            vaultTrancheStatePda: args.destinationVaultTrancheState
-          }
-        ] : []
+        {
+          vaultPda: args.vault,
+          vaultTrancheStatePda: args.vaultTrancheState ?? void 0,
+          withdrawalQueuePda: args.withdrawalQueue
+        }
       ]
     };
   }
-  async getTx(txArgs) {
-    const args = await this.deriveIxArgs(txArgs);
-    const preambleInstructions = await this.buildPreambleInstructions(args);
-    const instruction = await this.getIx(args);
-    const extras = await this.buildPlanExtras(args);
-    return this.withVaultLookupTables({
-      instructions: [...preambleInstructions, instruction],
-      ...extras
-    });
-  }
 };
 
 // src/client/transaction.ts
@@ -18288,6 +19038,8 @@ var TransactionClient = class {
     this.fulfillJuniorTrancheWithdraw = new FulfillJuniorTrancheWithdrawBuilder(
       context
     );
+    this.requestAsyncWithdraw = new RequestAsyncWithdrawBuilder(context);
+    this.fulfillAsyncWithdraw = new FulfillAsyncWithdrawBuilder(context);
     this.executeWithdraw = new ExecuteWithdrawBuilder(context);
     this.managerWithdrawAsset = new ManagerWithdrawAssetBuilder(context);
     this.managerRedepositAsset = new ManagerRedepositAssetBuilder(context);
@@ -18308,7 +19060,7 @@ var VaultClient = class {
     this.skipSimulation = options.skipSimulation ?? false;
     this.vaultLookupTables = options.vaultLookupTables;
     const idl = { ...IDL, address: programId };
-    this.program = new import_core21.Program(idl, provider);
+    this.program = new import_core22.Program(idl, provider);
     this.pda = new PdaClient((0, import_kit10.address)(this.program.programId.toBase58()));
     const rpc = createRpcFromConnection(provider.connection);
     this.account = new AccountClient(this.program, this.pda, rpc);
@@ -18336,15 +19088,15 @@ var VaultClient = class {
       this.vaultLookupTables
     );
     const { blockhash, lastValidBlockHeight } = await this.provider.connection.getLatestBlockhash("confirmed");
-    const instructions2 = plan.instructions.map(import_common46.fromKitInstruction);
+    const instructions2 = plan.instructions.map(import_common48.fromKitInstruction);
     let tx;
     if (plan.lookupTables?.length) {
-      const tables = await (0, import_common46.fetchLookupTables)(
+      const tables = await (0, import_common48.fetchLookupTables)(
         this.provider.connection,
         plan.lookupTables
       );
-      tx = new import_web327.VersionedTransaction(
-        new import_web327.TransactionMessage({
+      tx = new import_web329.VersionedTransaction(
+        new import_web329.TransactionMessage({
           payerKey: payer.publicKey,
           recentBlockhash: blockhash,
           instructions: instructions2
@@ -18352,7 +19104,7 @@ var VaultClient = class {
       );
       tx.sign([payer, ...extraSigners]);
     } else {
-      tx = new import_web327.Transaction().add(...instructions2);
+      tx = new import_web329.Transaction().add(...instructions2);
       tx.feePayer = payer.publicKey;
       tx.recentBlockhash = blockhash;
       tx.sign(payer, ...extraSigners);
@@ -18391,13 +19143,13 @@ var VaultClient = class {
     const { blockhash } = await this.provider.connection.getLatestBlockhash(
       "confirmed"
     );
-    const lookupTableAccounts = plan.lookupTables?.length ? await (0, import_common46.fetchLookupTables)(this.provider.connection, plan.lookupTables) : [];
-    const message2 = new import_web327.TransactionMessage({
+    const lookupTableAccounts = plan.lookupTables?.length ? await (0, import_common48.fetchLookupTables)(this.provider.connection, plan.lookupTables) : [];
+    const message2 = new import_web329.TransactionMessage({
       payerKey: payer.publicKey,
       recentBlockhash: blockhash,
-      instructions: plan.instructions.map(import_common46.fromKitInstruction)
+      instructions: plan.instructions.map(import_common48.fromKitInstruction)
     }).compileToV0Message(lookupTableAccounts);
-    const tx = new import_web327.VersionedTransaction(message2);
+    const tx = new import_web329.VersionedTransaction(message2);
     const result = await this.provider.connection.simulateTransaction(tx, {
       sigVerify: false,
       commitment: "processed"
@@ -18471,7 +19223,7 @@ function resolveKeypairPath(keypairPath) {
 }
 function loadKeypair(keypairPath) {
   const raw = import_fs.default.readFileSync(resolveKeypairPath(keypairPath), "utf-8");
-  return import_web328.Keypair.fromSecretKey(new Uint8Array(JSON.parse(raw)));
+  return import_web330.Keypair.fromSecretKey(new Uint8Array(JSON.parse(raw)));
 }
 var ENV_AGNOSTIC_ROLES = /* @__PURE__ */ new Set(["fulfiller", "rebalancer"]);
 function defaultKeypairPath(env, role = "vault") {
@@ -18482,8 +19234,8 @@ function defaultKeypairPath(env, role = "vault") {
 }
 function createVaultClient(env, opts = {}) {
   const payer = opts.keypair ?? loadKeypair(opts.keypairPath ?? defaultKeypairPath(env, opts.role));
-  const connection = new import_web328.Connection(opts.rpcUrl ?? getRpcUrl(env), "confirmed");
-  const provider = new import_core22.AnchorProvider(connection, new import_core22.Wallet(payer), {
+  const connection = new import_web330.Connection(opts.rpcUrl ?? getRpcUrl(env), "confirmed");
+  const provider = new import_core23.AnchorProvider(connection, new import_core23.Wallet(payer), {
     commitment: "confirmed"
   });
   const client = new VaultClient(
@@ -18499,11 +19251,11 @@ function createVaultClient(env, opts = {}) {
     client,
     provider,
     payer,
-    signer: (0, import_common47.fromWeb3Pk)(payer.publicKey)
+    signer: (0, import_common49.fromWeb3Pk)(payer.publicKey)
   };
 }
 function keypairAddress(keypairPath) {
-  return (0, import_common47.fromWeb3Pk)(loadKeypair(keypairPath).publicKey);
+  return (0, import_common49.fromWeb3Pk)(loadKeypair(keypairPath).publicKey);
 }
 
 // src/utils/math.ts
@@ -18517,16 +19269,16 @@ function fromUiAmount(amount, decimals) {
 }
 
 // src/utils/provider.ts
-var import_core23 = require("@anchor-lang/core");
+var import_core24 = require("@anchor-lang/core");
 function makeProvider(connection, payer) {
-  return new import_core23.AnchorProvider(connection, new import_core23.Wallet(payer), {
+  return new import_core24.AnchorProvider(connection, new import_core24.Wallet(payer), {
     commitment: "confirmed"
   });
 }
 
 // src/utils/squads.ts
 var squads = __toESM(require("@sqds/multisig"));
-var import_web329 = require("@solana/web3.js");
+var import_web331 = require("@solana/web3.js");
 var SQUADS_SIMULATION_COMMITMENT = "processed";
 var SquadsProposalExecutionSimulationError = class extends Error {
   constructor(transactionError, logs, unitsConsumed) {
@@ -18550,8 +19302,8 @@ function validateVaultIndex(vaultIndex) {
 }
 function resolveSquadsWalletRoute(route) {
   validateVaultIndex(route.vaultIndex);
-  const wallet = new import_web329.PublicKey(route.wallet);
-  const multisigPda = new import_web329.PublicKey(route.multisigPda);
+  const wallet = new import_web331.PublicKey(route.wallet);
+  const multisigPda = new import_web331.PublicKey(route.multisigPda);
   const [vaultPda] = squads.getVaultPda({
     multisigPda,
     index: route.vaultIndex
@@ -18559,7 +19311,7 @@ function resolveSquadsWalletRoute(route) {
   return { ...route, wallet, multisigPda, vaultPda };
 }
 function findSquadsWalletRoute(wallet, routes) {
-  const walletKey = typeof wallet === "string" ? new import_web329.PublicKey(wallet) : wallet;
+  const walletKey = typeof wallet === "string" ? new import_web331.PublicKey(wallet) : wallet;
   const route = routes.find(
     (candidate) => candidate.wallet === walletKey.toBase58()
   );
@@ -18577,18 +19329,18 @@ function validateSquadsWalletRoutes(routes) {
   }
 }
 function vaultAuthorityForWallet(wallet, routes) {
-  const walletKey = typeof wallet === "string" ? new import_web329.PublicKey(wallet) : wallet;
+  const walletKey = typeof wallet === "string" ? new import_web331.PublicKey(wallet) : wallet;
   return findSquadsWalletRoute(walletKey, routes)?.vaultPda ?? walletKey;
 }
 async function simulateSquadsProposalExecution(args) {
   const { connection, feePayer, instructions: instructions2 } = args;
   const recentBlockhash = args.recentBlockhash ?? (await connection.getLatestBlockhash(SQUADS_SIMULATION_COMMITMENT)).blockhash;
-  const message2 = new import_web329.TransactionMessage({
+  const message2 = new import_web331.TransactionMessage({
     payerKey: feePayer,
     recentBlockhash,
     instructions: [...instructions2]
   }).compileToV0Message(args.addressLookupTableAccounts);
-  const transaction = new import_web329.VersionedTransaction(message2);
+  const transaction = new import_web331.VersionedTransaction(message2);
   const { value } = await connection.simulateTransaction(transaction, {
     sigVerify: false,
     commitment: SQUADS_SIMULATION_COMMITMENT,
@@ -18613,7 +19365,7 @@ async function prepareVaultTransaction(args) {
       throw new Error("Ephemeral signers require a Squads route");
     return {
       kind: "direct",
-      transaction: new import_web329.Transaction().add(...instructions2),
+      transaction: new import_web331.Transaction().add(...instructions2),
       authority: proposer
     };
   }
@@ -18666,7 +19418,7 @@ async function prepareVaultTransaction(args) {
   });
   if (replacements.size) {
     instructions2 = instructions2.map(
-      (ix) => new import_web329.TransactionInstruction({
+      (ix) => new import_web331.TransactionInstruction({
         programId: ix.programId,
         data: ix.data,
         keys: ix.keys.map((meta) => ({
@@ -18694,7 +19446,7 @@ async function prepareVaultTransaction(args) {
       executionSimulationError = error;
     }
   }
-  const transactionMessage = new import_web329.TransactionMessage({
+  const transactionMessage = new import_web331.TransactionMessage({
     payerKey: route.vaultPda,
     recentBlockhash: blockhash,
     instructions: [...instructions2]
@@ -18724,7 +19476,7 @@ async function prepareVaultTransaction(args) {
   });
   return {
     kind: "squads",
-    transaction: new import_web329.Transaction().add(
+    transaction: new import_web331.Transaction().add(
       createVaultTransactionIx,
       createProposalIx
     ),
@@ -18740,16 +19492,16 @@ async function prepareVaultTransaction(args) {
 
 // src/utils/squadsBuffer.ts
 var squads2 = __toESM(require("@sqds/multisig"));
-var import_web330 = require("@solana/web3.js");
+var import_web332 = require("@solana/web3.js");
 var PacketSize = 1232;
 var BufferChunkSize = 700;
 var MaxBufferSize = 4e3;
 async function prepareSquadsProposalUpload(args) {
   const { connection, proposer, prepared } = args;
   const transaction = prepared.transaction;
-  const sizeProbe = new import_web330.Transaction({
+  const sizeProbe = new import_web332.Transaction({
     feePayer: proposer,
-    recentBlockhash: import_web330.PublicKey.default.toBase58()
+    recentBlockhash: import_web332.PublicKey.default.toBase58()
   }).add(...transaction.instructions);
   let fits = false;
   try {
@@ -18769,7 +19521,7 @@ async function prepareSquadsProposalUpload(args) {
   let bufferPda;
   let bufferIndex = 0;
   for (; bufferIndex <= 255; bufferIndex++) {
-    const [candidate] = import_web330.PublicKey.findProgramAddressSync(
+    const [candidate] = import_web332.PublicKey.findProgramAddressSync(
       [
         Buffer.from("multisig"),
         prepared.multisigPda.toBuffer(),
@@ -18797,7 +19549,7 @@ async function prepareSquadsProposalUpload(args) {
     creator: proposer
   };
   const setupTransactions = [
-    new import_web330.Transaction().add(
+    new import_web332.Transaction().add(
       squads2.generated.createTransactionBufferCreateInstruction(
         {
           ...accounts2,
@@ -18817,7 +19569,7 @@ async function prepareSquadsProposalUpload(args) {
   ];
   for (let offset = BufferChunkSize; offset < bytes.length; offset += BufferChunkSize) {
     setupTransactions.push(
-      new import_web330.Transaction().add(
+      new import_web332.Transaction().add(
         squads2.generated.createTransactionBufferExtendInstruction(accounts2, {
           args: { buffer: bytes.slice(offset, offset + BufferChunkSize) }
         })
@@ -18830,7 +19582,7 @@ async function prepareSquadsProposalUpload(args) {
       vaultTransactionCreateItemTransaction: prepared.vaultTransactionPda,
       vaultTransactionCreateItemCreator: proposer,
       vaultTransactionCreateItemRentPayer: proposer,
-      vaultTransactionCreateItemSystemProgram: import_web330.SystemProgram.programId,
+      vaultTransactionCreateItemSystemProgram: import_web332.SystemProgram.programId,
       transactionBuffer: bufferPda,
       creator: proposer
     },
@@ -18842,7 +19594,7 @@ async function prepareSquadsProposalUpload(args) {
   ).isWritable = true;
   return {
     setupTransactions,
-    proposalTransaction: new import_web330.Transaction().add(
+    proposalTransaction: new import_web332.Transaction().add(
       finalize,
       ...transaction.instructions.slice(1)
     ),
@@ -18852,21 +19604,21 @@ async function prepareSquadsProposalUpload(args) {
 }
 
 // src/utils/token.ts
-var import_spl_token21 = require("@solana/spl-token");
-var import_web331 = require("@solana/web3.js");
-var import_common48 = __toESM(require_dist());
-async function createTokenMintIxs(connection, payer, authority, decimals, tokenProgram = import_spl_token21.TOKEN_2022_PROGRAM_ID) {
-  const mint = import_web331.Keypair.generate();
-  const lamports = await (0, import_spl_token21.getMinimumBalanceForRentExemptMint)(connection);
+var import_spl_token23 = require("@solana/spl-token");
+var import_web333 = require("@solana/web3.js");
+var import_common50 = __toESM(require_dist());
+async function createTokenMintIxs(connection, payer, authority, decimals, tokenProgram = import_spl_token23.TOKEN_2022_PROGRAM_ID) {
+  const mint = import_web333.Keypair.generate();
+  const lamports = await (0, import_spl_token23.getMinimumBalanceForRentExemptMint)(connection);
   const ixs = [
-    import_web331.SystemProgram.createAccount({
+    import_web333.SystemProgram.createAccount({
       fromPubkey: payer,
       newAccountPubkey: mint.publicKey,
-      space: import_spl_token21.MINT_SIZE,
+      space: import_spl_token23.MINT_SIZE,
       lamports,
       programId: tokenProgram
     }),
-    (0, import_spl_token21.createInitializeMint2Instruction)(
+    (0, import_spl_token23.createInitializeMint2Instruction)(
       mint.publicKey,
       decimals,
       authority,
@@ -18876,7 +19628,7 @@ async function createTokenMintIxs(connection, payer, authority, decimals, tokenP
   ];
   return { mint, ixs };
 }
-async function createTokenMint(connection, payer, decimals, tokenProgram = import_spl_token21.TOKEN_2022_PROGRAM_ID) {
+async function createTokenMint(connection, payer, decimals, tokenProgram = import_spl_token23.TOKEN_2022_PROGRAM_ID) {
   const { mint, ixs } = await createTokenMintIxs(
     connection,
     payer.publicKey,
@@ -18885,7 +19637,7 @@ async function createTokenMint(connection, payer, decimals, tokenProgram = impor
     tokenProgram
   );
   const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-  const tx = new import_web331.Transaction().add(...ixs);
+  const tx = new import_web333.Transaction().add(...ixs);
   tx.feePayer = payer.publicKey;
   tx.recentBlockhash = blockhash;
   tx.sign(payer, mint);
@@ -18898,24 +19650,24 @@ async function createTokenMint(connection, payer, decimals, tokenProgram = impor
   );
   return mint.publicKey;
 }
-async function mintTokensTo(connection, payer, mint, destination, amount, tokenProgram = import_spl_token21.TOKEN_2022_PROGRAM_ID, allowOwnerOffCurve = true) {
-  const tokenProgramPk = (0, import_common48.asWeb3PublicKey)(tokenProgram);
-  const ata = (0, import_spl_token21.getAssociatedTokenAddressSync)(
+async function mintTokensTo(connection, payer, mint, destination, amount, tokenProgram = import_spl_token23.TOKEN_2022_PROGRAM_ID, allowOwnerOffCurve = true) {
+  const tokenProgramPk = (0, import_common50.asWeb3PublicKey)(tokenProgram);
+  const ata = (0, import_spl_token23.getAssociatedTokenAddressSync)(
     mint,
     destination,
     allowOwnerOffCurve,
     tokenProgramPk
   );
   const ixs = [
-    (0, import_spl_token21.createAssociatedTokenAccountIdempotentInstruction)(
+    (0, import_spl_token23.createAssociatedTokenAccountIdempotentInstruction)(
       payer.publicKey,
       ata,
       destination,
       mint,
       tokenProgramPk,
-      import_spl_token21.ASSOCIATED_TOKEN_PROGRAM_ID
+      import_spl_token23.ASSOCIATED_TOKEN_PROGRAM_ID
     ),
-    (0, import_spl_token21.createMintToInstruction)(
+    (0, import_spl_token23.createMintToInstruction)(
       mint,
       ata,
       payer.publicKey,
@@ -18924,12 +19676,12 @@ async function mintTokensTo(connection, payer, mint, destination, amount, tokenP
       tokenProgramPk
     )
   ];
-  const tx = new import_web331.Transaction().add(...ixs);
+  const tx = new import_web333.Transaction().add(...ixs);
   await connection.sendTransaction(tx, [payer]);
 }
 
 // src/utils/yieldApi.ts
-var import_core24 = require("@anchor-lang/core");
+var import_core25 = require("@anchor-lang/core");
 var YIELD_API_BASE = process.env.YIELD_API_BASE ?? "https://yield-tracker.perena.org";
 async function yieldApiReq(endpoint, reqType, bodyData, options) {
   const headers = {
@@ -19272,7 +20024,7 @@ async function getTrackedValue(accountName) {
   return trackedValueFromResponse(await getYield(accountName));
 }
 async function getTotalYield(accountNames, start, end) {
-  let totalYield = new import_core24.BN(0);
+  let totalYield = new import_core25.BN(0);
   for (const accountName of accountNames) {
     const res = await getYield(accountName, start, end);
     if (isNavAccountValue(res)) {
@@ -19281,7 +20033,7 @@ async function getTotalYield(accountNames, start, end) {
       );
     }
     console.log(res);
-    totalYield = totalYield.add(new import_core24.BN(res.total_yield));
+    totalYield = totalYield.add(new import_core25.BN(res.total_yield));
   }
   return totalYield;
 }
@@ -19314,7 +20066,7 @@ async function getTotalTrackedValue(accountNames, start, end, onAccountValue) {
 }
 
 // src/services/withdrawalQueueService.ts
-var import_common49 = __toESM(require_dist());
+var import_common51 = __toESM(require_dist());
 function bnToBigInt(value) {
   return BigInt(value.toString());
 }
@@ -19332,16 +20084,19 @@ var WithdrawalQueueService = class {
   // ── Discovery ───────────────────────────────────────────────────────────
   /** All withdrawal-queue accounts owned by the vault program. */
   async fetchAllQueues() {
-    const program = this.client.program.account;
-    const accounts2 = await program.vaultWithdrawalQueue.all();
+    const accounts2 = await this.client.account.fetchAllWithdrawalQueues();
     return accounts2.map(
-      (entry) => this.toSnapshot((0, import_common49.fromWeb3Pk)(entry.publicKey), entry.account)
+      ({ publicKey, account }) => this.toSnapshot(publicKey, account)
     );
   }
   /** Withdrawal queues for a single vault. */
   async fetchQueuesForVault(vault) {
-    const all = await this.fetchAllQueues();
-    return all.filter((q) => q.vault === vault);
+    const accounts2 = await this.client.account.fetchAllWithdrawalQueues({
+      vault
+    });
+    return accounts2.map(
+      ({ publicKey, account }) => this.toSnapshot(publicKey, account)
+    );
   }
   /** Fetch a single queue snapshot by owner/queueId for a vault. */
   async fetchQueue(vault, owner, queueId) {
@@ -19370,13 +20125,38 @@ var WithdrawalQueueService = class {
   }
   // ── Fulfillment ─────────────────────────────────────────────────────────
   /**
-   * Fulfill a single queued junior withdrawal. `signer` pays fees and, if
+   * Fulfill a single regular or junior withdrawal. `signer` pays fees and, if
    * needed, initializes the owner's output ATA.
    */
   async fulfill(signer, queue) {
+    const vault = await this.client.account.fetchVault(queue.vault, {
+      fresh: true
+    });
+    if (queue.inputMint === (0, import_common51.fromWeb3Pk)(vault.mint)) {
+      const plan2 = await this.client.tx.fulfillAsyncWithdraw.getTx({
+        owner: queue.owner,
+        signer: (0, import_common51.fromWeb3Pk)(signer.publicKey),
+        queuePayer: queue.payer,
+        vault: queue.vault,
+        withdrawalQueue: queue.pda,
+        assetMint: queue.outputMint,
+        shareMint: queue.inputMint,
+        queueId: queue.queueId
+      });
+      return this.client.sendTransaction(signer, plan2);
+    }
+    const tranche = await this.client.account.fetchVaultTrancheStateForVault(
+      queue.vault,
+      { fresh: true }
+    );
+    if (queue.inputMint !== (0, import_common51.fromWeb3Pk)(tranche.config.juniorMint)) {
+      throw new Error(
+        `Unsupported withdrawal queue input mint: ${queue.inputMint}`
+      );
+    }
     const plan = await this.client.tx.fulfillJuniorTrancheWithdraw.getTx({
       owner: queue.owner,
-      signer: (0, import_common49.fromWeb3Pk)(signer.publicKey),
+      signer: (0, import_common51.fromWeb3Pk)(signer.publicKey),
       queuePayer: queue.payer,
       vault: queue.vault,
       withdrawalQueue: queue.pda,
@@ -19410,7 +20190,7 @@ var WithdrawalQueueService = class {
       }
       try {
         log?.(
-          `fulfilling ${queue.pda} \u2014 paying ${queue.inputAmount} junior shares worth of ${queue.outputMint} to owner ${queue.owner}`
+          `fulfilling ${queue.pda} \u2014 paying ${queue.inputAmount} shares worth of ${queue.outputMint} to owner ${queue.owner}`
         );
         const sig = await this.fulfill(signer, queue);
         summary.fulfilled += 1;
@@ -19430,12 +20210,12 @@ var WithdrawalQueueService = class {
     const a = account;
     return {
       pda,
-      vault: (0, import_common49.fromWeb3Pk)(a.parties.vault),
-      owner: (0, import_common49.fromWeb3Pk)(a.parties.owner),
-      payer: (0, import_common49.fromWeb3Pk)(a.parties.payer),
+      vault: (0, import_common51.fromWeb3Pk)(a.parties.vault),
+      owner: (0, import_common51.fromWeb3Pk)(a.parties.owner),
+      payer: (0, import_common51.fromWeb3Pk)(a.parties.payer),
       queueId: a.header.queueId,
-      inputMint: (0, import_common49.fromWeb3Pk)(a.mints.inputMint),
-      outputMint: (0, import_common49.fromWeb3Pk)(a.mints.outputMint),
+      inputMint: (0, import_common51.fromWeb3Pk)(a.mints.inputMint),
+      outputMint: (0, import_common51.fromWeb3Pk)(a.mints.outputMint),
       inputAmount: bnToBigInt(a.request.inputAmount),
       requestTs: bnToNumber(a.request.requestTs),
       expiryTs: bnToNumber(a.request.expiryTs)
@@ -19445,7 +20225,7 @@ var WithdrawalQueueService = class {
 
 // src/services/oracleService.ts
 var import_kit12 = require("@solana/kit");
-var import_common50 = __toESM(require_dist());
+var import_common52 = __toESM(require_dist());
 var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
 var DEFAULT_PRICE_STALENESS_THRESHOLD_SECS2 = 86400n;
 var PRICE_ORACLE_TYPES_BY_INDEX2 = [
@@ -19509,7 +20289,7 @@ var OracleService = class {
    */
   async updateAssetConsensusPrice(signer, args, log) {
     const plan = await this.client.tx.updateConsensusOracle.getTx({
-      signer: (0, import_common50.fromWeb3Pk)(signer.publicKey),
+      signer: (0, import_common52.fromWeb3Pk)(signer.publicKey),
       vault: args.vault,
       updates: args.updates,
       assetMint: args.assetMint,
@@ -19525,7 +20305,7 @@ var OracleService = class {
   /** Settle the vault NAV from its current holdings (permissionless). */
   async crankNav(cranker, args, log) {
     const plan = await this.client.tx.crankNav.getTx({
-      cranker: (0, import_common50.fromWeb3Pk)(cranker.publicKey),
+      cranker: (0, import_common52.fromWeb3Pk)(cranker.publicKey),
       vault: args.vault,
       vaultTrancheState: args.vaultTrancheState
     });
@@ -19598,7 +20378,7 @@ var OracleService = class {
   /** Re-price one live-oracle holding from its bound Pyth/nested-vault account. */
   async refreshAssetPrice(updater, args, log) {
     const plan = await this.client.tx.updateAssetPrice.getTx({
-      updater: (0, import_common50.fromWeb3Pk)(updater.publicKey),
+      updater: (0, import_common52.fromWeb3Pk)(updater.publicKey),
       vault: args.vault,
       mint: args.mint,
       oracleAccount: args.oracleAccount,
@@ -19694,11 +20474,11 @@ function toBigInt2(value) {
 }
 
 // src/services/consensusOracle/utils/holdings.ts
-var import_web332 = require("@solana/web3.js");
-var import_common51 = __toESM(require_dist());
+var import_web334 = require("@solana/web3.js");
+var import_common53 = __toESM(require_dist());
 function selectReportableHoldings(holdings, excludedMints = /* @__PURE__ */ new Set()) {
   return holdings.map((holding, holdingIndex) => ({ holding, holdingIndex })).filter(({ holding }) => {
-    const mint = (0, import_common51.fromWeb3Pk)(holding.mint);
+    const mint = (0, import_common53.fromWeb3Pk)(holding.mint);
     return mint !== SYSTEM_PROGRAM && !excludedMints.has(mint.toString()) && REPORTABLE_ORACLE_VARIANTS.has(
       variantName2(holding.priceOracleType).toLowerCase()
     );
@@ -19733,7 +20513,7 @@ function parseExternalLiquidityRefs(vaultState) {
     if (!data || data.length < 40) continue;
     if (data[0] !== 1 && data[0] !== 2) continue;
     const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-    const userAccount = new import_web332.PublicKey(pubkeyBytes).toBase58();
+    const userAccount = new import_web334.PublicKey(pubkeyBytes).toBase58();
     refs.push(
       data[0] === 1 ? { kind: "marginfi", mint: "", marginfiAccount: userAccount } : {
         kind: "kamino-lend",
@@ -19961,12 +20741,12 @@ function formatBpsAsPercent(bps) {
 }
 
 // src/services/consensusOracle/pipeline/dryRunSettlement.ts
-var import_web334 = require("@solana/web3.js");
-var import_common52 = __toESM(require_dist());
+var import_web336 = require("@solana/web3.js");
+var import_common54 = __toESM(require_dist());
 
 // src/services/consensusOracle/settlement/settlementSimulator.ts
 var import_kit13 = require("@solana/kit");
-var import_web333 = require("@solana/web3.js");
+var import_web335 = require("@solana/web3.js");
 var DEFAULT_SHARE_PRICE = 1000000n;
 var BPS_DENOMINATOR3 = 10000n;
 var NAV_LOSS_TOLERANCE_BPS = 1n;
@@ -20239,7 +21019,7 @@ function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
       continue;
     }
     const reports = entries.filter(
-      (entry) => entry.signer !== import_web333.PublicKey.default.toBase58() && isFresh(entry.lastUpdateTs, nowTs, stalenessThresholdSecs) && (entry.prices[index] ?? 0n) > 0n
+      (entry) => entry.signer !== import_web335.PublicKey.default.toBase58() && isFresh(entry.lastUpdateTs, nowTs, stalenessThresholdSecs) && (entry.prices[index] ?? 0n) > 0n
     );
     const usesConsensusPrice = holding.priceOracleType === "consensusoracle";
     const prices = reports.map((entry) => entry.prices[index] ?? 0n);
@@ -20740,7 +21520,7 @@ function decodeOracleData(data, nowTs) {
       (_, holdingIndex) => readU64(data, offset + EXTERNAL_OFFSET + holdingIndex * 8)
     );
     entries.push({
-      signer: new import_web333.PublicKey(signerBytes).toBase58(),
+      signer: new import_web335.PublicKey(signerBytes).toBase58(),
       lastUpdateTs: readI64(data, offset + 32),
       prices,
       externalAmounts
@@ -20755,7 +21535,7 @@ function decodeOracleData(data, nowTs) {
         data.slice(pendingOffset + index * 32, pendingOffset + (index + 1) * 32)
       );
       entries[index] = {
-        signer: index < pendingCount ? new import_web333.PublicKey(signerBytes).toBase58() : import_web333.PublicKey.default.toBase58(),
+        signer: index < pendingCount ? new import_web335.PublicKey(signerBytes).toBase58() : import_web335.PublicKey.default.toBase58(),
         lastUpdateTs: 0n,
         prices: Array(MAX_HOLDINGS).fill(0n),
         externalAmounts: Array(MAX_HOLDINGS).fill(0n)
@@ -20783,7 +21563,7 @@ function decodeHolding(value) {
     externalAmount: bigint(holding.externalAmount),
     price: bigint(holding.price),
     lastUpdateTs: bigint(holding.lastUpdateTs),
-    cleared: mintString === import_web333.PublicKey.default.toBase58()
+    cleared: mintString === import_web335.PublicKey.default.toBase58()
   };
 }
 function decodeTrancheState(decoded, args, warnings, blockers) {
@@ -21266,11 +22046,11 @@ async function fetchSimulationArgs({
     client.account.fetchVaultOracleForVault(vault, { fresh: true }),
     tranchingEnabled ? client.account.fetchVaultTrancheStateForVault(vault, { fresh: true }) : Promise.resolve(void 0)
   ]);
-  const mintKeys = [new import_web334.PublicKey(vaultState.mint)];
+  const mintKeys = [new import_web336.PublicKey(vaultState.mint)];
   if (trancheState) {
     mintKeys.push(
-      new import_web334.PublicKey(trancheState.config.juniorMint),
-      new import_web334.PublicKey(trancheState.config.seniorMint)
+      new import_web336.PublicKey(trancheState.config.juniorMint),
+      new import_web336.PublicKey(trancheState.config.seniorMint)
     );
   }
   const mintAccounts = await client.provider.connection.getMultipleAccountsInfo(
@@ -21286,7 +22066,7 @@ async function fetchSimulationArgs({
     oracleData: oracleState.data,
     trancheState,
     updates,
-    signer: (0, import_common52.fromWeb3Pk)(signer.publicKey),
+    signer: (0, import_common54.fromWeb3Pk)(signer.publicKey),
     nowTs: nowSecs,
     physicalShareSupply: supplies[0],
     physicalJuniorSupply: tranchingEnabled ? supplies[1] : void 0,
@@ -21295,7 +22075,7 @@ async function fetchSimulationArgs({
 }
 
 // src/services/consensusOracle/pipeline/holdingUpdates.ts
-var import_common53 = __toESM(require_dist());
+var import_common55 = __toESM(require_dist());
 async function buildUpdates(yieldTracker, reportableHoldings, inputs) {
   const updates = [];
   for (const entry of reportableHoldings) {
@@ -21305,7 +22085,7 @@ async function buildUpdates(yieldTracker, reportableHoldings, inputs) {
 }
 async function buildHoldingUpdate(yieldTracker, entry, inputs) {
   const { holding, holdingIndex } = entry;
-  const mint = (0, import_common53.fromWeb3Pk)(holding.mint);
+  const mint = (0, import_common55.fromWeb3Pk)(holding.mint);
   const mintKey = mint.toString();
   const oracleType = variantName2(holding.priceOracleType).toLowerCase();
   let usd;
@@ -21367,9 +22147,9 @@ async function resolveTrackedAmounts(yieldTracker, cfg, decimals) {
     );
   }
   return {
-    trackedValueAmount: tracked.totalValue > 0 ? (0, import_common53.fromUiAmount)(tracked.totalValue, decimals) : 0n,
-    principalAmount: tracked.principal > 0 ? (0, import_common53.fromUiAmount)(tracked.principal, decimals) : 0n,
-    yieldAmount: tracked.outstandingYield > 0 ? (0, import_common53.fromUiAmount)(tracked.outstandingYield, decimals) : 0n
+    trackedValueAmount: tracked.totalValue > 0 ? (0, import_common55.fromUiAmount)(tracked.totalValue, decimals) : 0n,
+    principalAmount: tracked.principal > 0 ? (0, import_common55.fromUiAmount)(tracked.principal, decimals) : 0n,
+    yieldAmount: tracked.outstandingYield > 0 ? (0, import_common55.fromUiAmount)(tracked.outstandingYield, decimals) : 0n
   };
 }
 
@@ -21403,7 +22183,7 @@ function assertOracleImpliedApy(vault, simulation, label) {
 }
 
 // src/services/consensusOracle/pipeline/livePriceRefresh.ts
-var import_common54 = __toESM(require_dist());
+var import_common56 = __toESM(require_dist());
 async function refreshLiveOraclePrices({
   oracle,
   signer,
@@ -21422,7 +22202,7 @@ async function refreshLiveOraclePrices({
   for (const holding of vaultState.holdings) {
     const oracleType = variantName2(holding.priceOracleType).toLowerCase();
     if (!LIVE_ORACLE_VARIANTS.has(oracleType)) continue;
-    const mint = (0, import_common54.fromWeb3Pk)(holding.mint);
+    const mint = (0, import_common56.fromWeb3Pk)(holding.mint);
     if (mint.toString() === SYSTEM_PROGRAM) continue;
     const activeAmount = toBigInt2(holding.localAmount) + toBigInt2(holding.externalAmount);
     if (activeAmount === 0n) continue;
@@ -21437,7 +22217,7 @@ async function refreshLiveOraclePrices({
       );
       continue;
     }
-    const oracleAccount = (0, import_common54.fromWeb3Pk)(holding.priceOracleAccount);
+    const oracleAccount = (0, import_common56.fromWeb3Pk)(holding.priceOracleAccount);
     if (oracleAccount.toString() === SYSTEM_PROGRAM) {
       log(
         `vault ${vault}: cannot refresh ${mint}; ${oracleType} holding has no oracle account`
@@ -21461,7 +22241,7 @@ async function refreshLiveOraclePrices({
 }
 
 // src/services/consensusOracle/pipeline/managerWalletReconciliation.ts
-var import_common55 = __toESM(require_dist());
+var import_common57 = __toESM(require_dist());
 
 // src/services/consensusOracle/sources/nestPriceSource.ts
 var import_kit14 = require("@solana/kit");
@@ -21508,13 +22288,13 @@ function candidateGrossNav(state, updates) {
   const byIndex = /* @__PURE__ */ new Map();
   for (const update of updates) {
     const holding = state.holdings[update.holdingIndex];
-    if (!holding || (0, import_common55.fromWeb3Pk)(holding.mint) !== update.mint || holding.decimals !== update.decimals || byIndex.has(update.holdingIndex)) {
+    if (!holding || (0, import_common57.fromWeb3Pk)(holding.mint) !== update.mint || holding.decimals !== update.decimals || byIndex.has(update.holdingIndex)) {
       throw new Error(`Invalid NAV update for holding #${update.holdingIndex}`);
     }
     byIndex.set(update.holdingIndex, update);
   }
   return state.holdings.reduce((nav, holding, index) => {
-    if ((0, import_common55.fromWeb3Pk)(holding.mint) === SYSTEM_PROGRAM) return nav;
+    if ((0, import_common57.fromWeb3Pk)(holding.mint) === SYSTEM_PROGRAM) return nav;
     const update = byIndex.get(index);
     const local = toBigInt2(holding.localAmount);
     const external = update?.externalAmount ?? toBigInt2(holding.externalAmount);
@@ -21581,13 +22361,13 @@ async function reconcileManagerWalletBalances({
     throw new Error("Duplicate base mint in manager reconciliation");
   }
   if (vaultState.holdings.some(
-    (holding) => coerceBool3(holding.isBase) && !mints2.includes((0, import_common55.fromWeb3Pk)(holding.mint))
+    (holding) => coerceBool3(holding.isBase) && !mints2.includes((0, import_common57.fromWeb3Pk)(holding.mint))
   )) {
     throw new Error(
       "Cannot reconcile all vault base assets with oracle reports"
     );
   }
-  const manager = (0, import_common55.fromWeb3Pk)(vaultState.roles.manager);
+  const manager = (0, import_common57.fromWeb3Pk)(vaultState.roles.manager);
   if (manager === SYSTEM_PROGRAM || manager === vault) {
     throw new Error("Invalid manager wallet for NAV reconciliation");
   }
@@ -21673,13 +22453,13 @@ function walletReconciliationGuardUpdates(state, reconciliation) {
 }
 function managerReconciliationStateKey(state) {
   return JSON.stringify({
-    manager: (0, import_common55.fromWeb3Pk)(state.roles.manager),
+    manager: (0, import_common57.fromWeb3Pk)(state.roles.manager),
     assetDecimals: state.config.assetDecimals,
     holdings: state.holdings.map((holding) => [
-      (0, import_common55.fromWeb3Pk)(holding.mint),
+      (0, import_common57.fromWeb3Pk)(holding.mint),
       holding.decimals,
       variantName2(holding.priceOracleType),
-      holding.priceOracleAccount ? (0, import_common55.fromWeb3Pk)(holding.priceOracleAccount) : void 0,
+      holding.priceOracleAccount ? (0, import_common57.fromWeb3Pk)(holding.priceOracleAccount) : void 0,
       coerceBool3(holding.isBase),
       toBigInt2(holding.localAmount).toString()
     ])
@@ -21718,14 +22498,14 @@ function assertReconciliationExternalValues(initial, current, errorPrefix) {
 }
 
 // src/services/consensusOracle/pipeline/pricingInputs.ts
-var import_common56 = __toESM(require_dist());
+var import_common58 = __toESM(require_dist());
 async function gatherPricingInputs(deps, target, vaultState, reportableHoldings, log = () => {
 }) {
   const consensusMints = reportableHoldings.filter(
     ({ holding }) => variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT
-  ).map(({ holding }) => (0, import_common56.fromWeb3Pk)(holding.mint));
+  ).map(({ holding }) => (0, import_common58.fromWeb3Pk)(holding.mint));
   const baseHolding = vaultState.holdings.find((h) => coerceBool3(h.isBase));
-  const baseMint = baseHolding ? (0, import_common56.fromWeb3Pk)(baseHolding.mint) : consensusMints[0];
+  const baseMint = baseHolding ? (0, import_common58.fromWeb3Pk)(baseHolding.mint) : consensusMints[0];
   if (!baseMint) {
     throw new Error(`vault has no holdings \u2014 cannot determine base asset`);
   }
@@ -21811,11 +22591,11 @@ function reconcilePositionSnapshots(snapshots, vault, log) {
 }
 
 // src/services/consensusOracle/pipeline/receiptMints.ts
-var import_common57 = __toESM(require_dist());
+var import_common59 = __toESM(require_dist());
 async function fetchReceiptMints(client, vault, vaultState) {
   const receiptMints = /* @__PURE__ */ new Set();
   if (vaultState.mint) {
-    receiptMints.add((0, import_common57.fromWeb3Pk)(vaultState.mint).toString());
+    receiptMints.add((0, import_common59.fromWeb3Pk)(vaultState.mint).toString());
   }
   if (!coerceBool3(vaultState.tranchingEnabled)) return receiptMints;
   const trancheState = await client.account.fetchVaultTrancheStateForVault(
@@ -21823,19 +22603,19 @@ async function fetchReceiptMints(client, vault, vaultState) {
     { fresh: true }
   );
   receiptMints.add(
-    (0, import_common57.fromWeb3Pk)(trancheState.config.juniorMint).toString()
+    (0, import_common59.fromWeb3Pk)(trancheState.config.juniorMint).toString()
   );
   receiptMints.add(
-    (0, import_common57.fromWeb3Pk)(trancheState.config.seniorMint).toString()
+    (0, import_common59.fromWeb3Pk)(trancheState.config.seniorMint).toString()
   );
   return receiptMints;
 }
 
 // src/services/consensusOracle/pipeline/settlement.ts
-var import_common59 = __toESM(require_dist());
+var import_common61 = __toESM(require_dist());
 
 // src/services/consensusOracle/pipeline/yieldAccounts.ts
-var import_common58 = __toESM(require_dist());
+var import_common60 = __toESM(require_dist());
 async function assertNoUnconfirmedYieldPayments(yieldTracker, target) {
   const accountNames = [
     ...new Set(
@@ -21877,7 +22657,7 @@ async function withDiscoveredYieldAccounts(yieldTracker, target, vaultState, exc
   );
   if (namesToAttach.length === 0) return target;
   const baseHolding = vaultState.holdings.find((holding) => {
-    const mint = (0, import_common58.fromWeb3Pk)(holding.mint).toString();
+    const mint = (0, import_common60.fromWeb3Pk)(holding.mint).toString();
     return coerceBool3(holding.isBase) && !excludedMints.has(mint);
   });
   if (!baseHolding) {
@@ -21885,7 +22665,7 @@ async function withDiscoveredYieldAccounts(yieldTracker, target, vaultState, exc
       `vault ${target.vault}: tagged yield accounts found but no base holding is available`
     );
   }
-  const baseMint = (0, import_common58.fromWeb3Pk)(baseHolding.mint);
+  const baseMint = (0, import_common60.fromWeb3Pk)(baseHolding.mint);
   const holdings = [...target.holdings ?? []];
   const existingIndex = holdings.findIndex(
     (holding) => holding.mint.toString() === baseMint.toString()
@@ -21970,7 +22750,7 @@ async function settleVault2({
       vault: publishedVault,
       oracleData: publishedOracle.data,
       updates,
-      signer: (0, import_common59.fromWeb3Pk)(signer.publicKey),
+      signer: (0, import_common61.fromWeb3Pk)(signer.publicKey),
       nowTs: publishedAt
     });
     if (blockers.length)
@@ -22012,7 +22792,7 @@ async function logProspectiveApy({
     );
     const prospectiveNav = vaultState.holdings.reduce(
       (sum, holding, holdingIndex) => {
-        const mint = (0, import_common59.fromWeb3Pk)(holding.mint).toString();
+        const mint = (0, import_common61.fromWeb3Pk)(holding.mint).toString();
         if (mint === SYSTEM_PROGRAM) return sum;
         const update = updatesByIndex.get(holdingIndex);
         const localAmount = toBigInt2(holding.localAmount);
@@ -22050,20 +22830,38 @@ async function discoverVaultsForSigner(client, signer, opts = {}) {
   log(
     `Discovered ${allVaults.length} vault(s) on-chain, checking oracle membership\u2026`
   );
-  const results = [];
-  await Promise.all(
+  const inspections = await Promise.allSettled(
     allVaults.map(async ({ publicKey: vault }) => {
-      try {
-        const oracle = await client.account.fetchVaultOracleForVault(vault);
-        const data = oracle.data;
-        if (signerInOracleData(data, signerBytes)) {
-          log(`  ${vault}: signer is registered oracle`);
-          results.push({ vault });
-        }
-      } catch {
-      }
+      const oracle = await client.account.fetchVaultOracleForVaultNullable(
+        vault
+      );
+      if (!oracle) {
+        log(`  ${vault}: no oracle account, skipping`);
+        return null;
+      }
+      const data = oracle.data;
+      if (!signerInOracleData(data, signerBytes)) return null;
+      log(`  ${vault}: signer is registered oracle`);
+      return { vault };
     })
   );
+  const results = [];
+  const unreadable = [];
+  inspections.forEach((inspection, index) => {
+    if (inspection.status === "fulfilled") {
+      if (inspection.value) results.push(inspection.value);
+      return;
+    }
+    const vault = allVaults[index].publicKey;
+    const error = inspection.reason instanceof Error ? inspection.reason.message : String(inspection.reason);
+    log(`FAILED oracle discovery ${vault}: ${error}`);
+    unreadable.push(vault.toString());
+  });
+  if (unreadable.length > 0) {
+    throw new Error(
+      `Oracle discovery incomplete: could not inspect ${unreadable.length}/${allVaults.length} vault(s) (${unreadable.join(", ")}); refusing to run a partial target list`
+    );
+  }
   return results;
 }
 
@@ -22921,7 +23719,7 @@ async function buildJupiterSwapTransaction(params) {
 }
 
 // ../jupiter/src/client.ts
-var import_common60 = __toESM(require_dist());
+var import_common62 = __toESM(require_dist());
 
 // ../jupiter/src/extract.ts
 var import_kit17 = require("@solana/kit");
@@ -22951,8 +23749,8 @@ async function extractJupiterInstruction(transaction, rpc, jupiterProgramId = JU
 
 // ../jupiter/src/routePreInstructions.ts
 var import_kit18 = require("@solana/kit");
-var import_spl_token22 = require("@solana/spl-token");
-var import_web335 = require("@solana/web3.js");
+var import_spl_token24 = require("@solana/spl-token");
+var import_web337 = require("@solana/web3.js");
 async function getJupiterRoutePreInstructions(rpc, quote, user, payer) {
   const intermediate = /* @__PURE__ */ new Set();
   for (const step of quote.routePlan ?? []) {
@@ -22976,26 +23774,26 @@ async function getJupiterRoutePreInstructions(rpc, quote, user, payer) {
         `getJupiterRoutePreInstructions: route mint ${mint} not found on-chain`
       );
     }
-    const ata = (0, import_spl_token22.getAssociatedTokenAddressSync)(
-      new import_web335.PublicKey(mint),
-      new import_web335.PublicKey(user),
+    const ata = (0, import_spl_token24.getAssociatedTokenAddressSync)(
+      new import_web337.PublicKey(mint),
+      new import_web337.PublicKey(user),
       true,
-      new import_web335.PublicKey(tokenProgram),
-      import_spl_token22.ASSOCIATED_TOKEN_PROGRAM_ID
+      new import_web337.PublicKey(tokenProgram),
+      import_spl_token24.ASSOCIATED_TOKEN_PROGRAM_ID
     ).toBase58();
     const existingAta = await rpc.getAccountInfo(ata, { encoding: "base64" }).send();
     if (existingAta.value) {
       continue;
     }
     instructions2.push(
-      toKitInstruction37(
-        (0, import_spl_token22.createAssociatedTokenAccountIdempotentInstruction)(
-          new import_web335.PublicKey(payer),
-          new import_web335.PublicKey(ata),
-          new import_web335.PublicKey(user),
-          new import_web335.PublicKey(mint),
-          new import_web335.PublicKey(tokenProgram),
-          import_spl_token22.ASSOCIATED_TOKEN_PROGRAM_ID
+      toKitInstruction39(
+        (0, import_spl_token24.createAssociatedTokenAccountIdempotentInstruction)(
+          new import_web337.PublicKey(payer),
+          new import_web337.PublicKey(ata),
+          new import_web337.PublicKey(user),
+          new import_web337.PublicKey(mint),
+          new import_web337.PublicKey(tokenProgram),
+          import_spl_token24.ASSOCIATED_TOKEN_PROGRAM_ID
         )
       )
     );
@@ -23003,7 +23801,7 @@ async function getJupiterRoutePreInstructions(rpc, quote, user, payer) {
   }
   return { instructions: instructions2, postSuccessCacheInvalidations };
 }
-function toKitInstruction37(ix) {
+function toKitInstruction39(ix) {
   return {
     programAddress: ix.programId.toBase58(),
     accounts: ix.keys.map((account) => ({
@@ -23120,7 +23918,7 @@ var JupiterSwapClient = class {
       }
     }
     return {
-      cpiType: this.config.cpiType ?? import_common60.CpiTypes.JUPITER_SWAP,
+      cpiType: this.config.cpiType ?? import_common62.CpiTypes.JUPITER_SWAP,
       data,
       accounts: accounts2,
       programId: JUPITER_V6_PROGRAM_ID,
@@ -23218,8 +24016,8 @@ var LivePriceSource = class {
 };
 
 // src/services/consensusOracle/sources/managerWalletBalanceSource.ts
-var import_web336 = require("@solana/web3.js");
-var import_spl_token23 = require("@solana/spl-token");
+var import_web338 = require("@solana/web3.js");
+var import_spl_token25 = require("@solana/spl-token");
 var RpcManagerWalletBalanceSource = class {
   constructor(connection) {
     this.connection = connection;
@@ -23227,8 +24025,8 @@ var RpcManagerWalletBalanceSource = class {
   async fetchBalances(manager, mints2) {
     const wanted = new Set(mints2);
     if (wanted.size === 0) return /* @__PURE__ */ new Map();
-    const owner = new import_web336.PublicKey(manager);
-    const programs = [import_spl_token23.TOKEN_PROGRAM_ID, import_spl_token23.TOKEN_2022_PROGRAM_ID];
+    const owner = new import_web338.PublicKey(manager);
+    const programs = [import_spl_token25.TOKEN_PROGRAM_ID, import_spl_token25.TOKEN_2022_PROGRAM_ID];
     const responses = await Promise.all(
       programs.map(
         (programId) => this.connection.getParsedTokenAccountsByOwner(
@@ -23271,7 +24069,7 @@ var RpcManagerWalletBalanceSource = class {
 };
 
 // src/services/consensusOracle/sources/mpcWalletBalanceSource.ts
-var import_web337 = require("@solana/web3.js");
+var import_web339 = require("@solana/web3.js");
 
 // src/services/consensusOracle/sources/mpcMarginfiDeposits.ts
 var import_kit19 = require("@solana/kit");
@@ -23360,8 +24158,8 @@ var RpcMpcWalletBalanceSource = class {
     const wallets = /* @__PURE__ */ new Set();
     for (const binding of bindings) {
       const { vault, manager, wallet } = binding;
-      for (const key of [vault, manager, wallet]) new import_web337.PublicKey(key);
-      if (entries.has(vault) || wallets.has(wallet) || wallet === manager || wallet === vault || wallet === import_web337.PublicKey.default.toBase58())
+      for (const key of [vault, manager, wallet]) new import_web339.PublicKey(key);
+      if (entries.has(vault) || wallets.has(wallet) || wallet === manager || wallet === vault || wallet === import_web339.PublicKey.default.toBase58())
         throw new Error("Invalid or duplicate MPC wallet binding");
       entries.set(vault, { ...binding });
       wallets.add(wallet);
@@ -23381,8 +24179,8 @@ var RpcMpcWalletBalanceSource = class {
       this.tokens.fetchBalances(binding.wallet, mints2),
       readMarginfiDepositsForAuthority(
         this.connection,
-        new import_web337.PublicKey(binding.wallet),
-        mints2.map((mint) => new import_web337.PublicKey(mint))
+        new import_web339.PublicKey(binding.wallet),
+        mints2.map((mint) => new import_web339.PublicKey(mint))
       )
     ]);
     return { wallet: binding.wallet, tokens, marginfi: deposits };
@@ -23425,7 +24223,7 @@ var StaticPositionProvider = class {
 
 // src/services/consensusOracle/positions/kaminoPositionProvider.ts
 var import_kit20 = require("@solana/kit");
-var import_web338 = require("@solana/web3.js");
+var import_web340 = require("@solana/web3.js");
 var import_klend_sdk = require("@kamino-finance/klend-sdk");
 async function readKaminoBalance(manager, vault, sharesHolder) {
   const userShares = await manager.getUserSharesBalanceSingleVault(
@@ -23462,7 +24260,7 @@ var KaminoPositionProvider = class {
       const amount = await readKaminoBalance(
         manager,
         kVault,
-        new import_web338.PublicKey(sharesHolder)
+        new import_web340.PublicKey(sharesHolder)
       );
       out.push({ mint: ref.mint, amount });
     }
@@ -23471,11 +24269,11 @@ var KaminoPositionProvider = class {
 };
 
 // src/services/consensusOracle/positions/kaminoLendPositionProvider.ts
-var import_web339 = require("@solana/web3.js");
+var import_web341 = require("@solana/web3.js");
 var import_Obligation2 = require("@kamino-finance/klend-sdk/dist/@codegen/klend/accounts/Obligation");
 var import_Reserve2 = require("@kamino-finance/klend-sdk/dist/@codegen/klend/accounts/Reserve");
 var import_kamino4 = __toESM(require_dist3());
-var ZERO = import_web339.PublicKey.default.toBase58();
+var ZERO = import_web341.PublicKey.default.toBase58();
 var FRACTION_SCALE = 1n << 60n;
 function accountData(info, label) {
   if (!info || info.executable || info.owner.toBase58() !== import_kamino4.KLEND_PROGRAM_ID)
@@ -23516,7 +24314,7 @@ var KaminoLendPositionProvider = class {
     }
     const positions = [];
     for (const address18 of obligations) {
-      const key = new import_web339.PublicKey(address18);
+      const key = new import_web341.PublicKey(address18);
       const discovered = decodeObligation(
         await this.connection.getAccountInfo(key, "confirmed"),
         ctx.vault
@@ -23526,7 +24324,7 @@ var KaminoLendPositionProvider = class {
         (deposit) => deposit.depositReserve
       );
       const infos = await this.connection.getMultipleAccountsInfo(
-        [key, ...reserves.map((reserve) => new import_web339.PublicKey(reserve))],
+        [key, ...reserves.map((reserve) => new import_web341.PublicKey(reserve))],
         "confirmed"
       );
       const { obligation, deposits } = decodeObligation(
@@ -23568,7 +24366,7 @@ var KaminoLendPositionProvider = class {
 };
 
 // src/services/consensusOracle/positions/marginfiPositionProvider.ts
-var import_web340 = require("@solana/web3.js");
+var import_web342 = require("@solana/web3.js");
 var import_marginfi4 = __toESM(require_dist2());
 var MarginfiPositionProvider = class {
   constructor(connection, log = () => {
@@ -23579,8 +24377,8 @@ var MarginfiPositionProvider = class {
   async positionsFor(ctx) {
     const refs = ctx.refs.filter((r) => r.kind === "marginfi");
     if (refs.length === 0) return [];
-    const explicitBanks = refs.map((r) => r.marginfiBank).filter(Boolean).map((bank) => new import_web340.PublicKey(bank));
-    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web340.PublicKey(account));
+    const explicitBanks = refs.map((r) => r.marginfiBank).filter(Boolean).map((bank) => new import_web342.PublicKey(bank));
+    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web342.PublicKey(account));
     const autoBanks = [];
     for (const accountPk of autoAccountPks) {
       try {
@@ -23609,14 +24407,14 @@ var MarginfiPositionProvider = class {
       if (bank) {
         const amount = await (0, import_marginfi4.readMarginfiBankBalance)(
           client,
-          new import_web340.PublicKey(account),
-          new import_web340.PublicKey(bank)
+          new import_web342.PublicKey(account),
+          new import_web342.PublicKey(bank)
         );
         out.push({ mint: ref.mint, amount });
       } else {
         const balances = await (0, import_marginfi4.readAllMarginfiBalances)(
           client,
-          new import_web340.PublicKey(account)
+          new import_web342.PublicKey(account)
         );
         for (const { mint, amount } of balances) {
           out.push({ mint: mint.toBase58(), amount });
@@ -23823,6 +24621,11 @@ var MPC_WALLETS = [
     vault: (0, import_kit21.address)("ECJGrTZ6QYMEwiEAnL4oReWF126uc22e9Lojy9qyCjHT"),
     manager: (0, import_kit21.address)("4jMRBkpWrfhhwFYTwG3o7hmsXQwbJUwdyUX8htB6KwLJ"),
     wallet: (0, import_kit21.address)("4EXphBhAWcm8NHEENzURiJBPtMPsg2PoXWf95E6sRyfB")
+  },
+  {
+    vault: (0, import_kit21.address)("JBmJMnnGfw4gL3e6Xs4a6H4NV1cC9jitRx1GUP2bGq37"),
+    manager: (0, import_kit21.address)("AybcEps9z8eUug3ct6L7KkLMH3SVG2Ss3dRVya7ave9n"),
+    wallet: (0, import_kit21.address)("7U4ZkXNGVi3648fbAXpUD47DARsP6kpRWqrXFoMxk2t1")
   }
 ];
 
@@ -23881,7 +24684,7 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
 }
 
 // src/services/consensusOracle/consensusOracleService.ts
-var import_common61 = __toESM(require_dist());
+var import_common63 = __toESM(require_dist());
 var ConsensusOracleService = class {
   constructor(client, deps) {
     this.client = client;
@@ -23917,7 +24720,7 @@ var ConsensusOracleService = class {
       receiptMints
     );
     const filteredCount = vaultState.holdings.filter(
-      (holding) => receiptMints.has((0, import_common61.fromWeb3Pk)(holding.mint).toString())
+      (holding) => receiptMints.has((0, import_common63.fromWeb3Pk)(holding.mint).toString())
     ).length;
     if (filteredCount > 0) {
       log(
@@ -24186,8 +24989,8 @@ async function runLiveConsensusOracle(env, oracleSigner, opts = {}) {
 
 // src/services/externalLiquidityIntegrityService.ts
 var import_kit22 = require("@solana/kit");
-var import_web341 = require("@solana/web3.js");
-var import_common62 = __toESM(require_dist());
+var import_web343 = require("@solana/web3.js");
+var import_common64 = __toESM(require_dist());
 var import_marginfi5 = __toESM(require_dist2());
 var import_kamino5 = __toESM(require_dist3());
 var import_marginfi_client_v23 = require("@mrgnlabs/marginfi-client-v2");
@@ -24297,7 +25100,7 @@ function parseActiveSlots(externalLiquidity) {
     if (discriminant === 0) continue;
     if (discriminant !== 1 && discriminant !== 2) continue;
     const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-    const userAccount = (0, import_common62.toAddress)(new import_web341.PublicKey(pubkeyBytes));
+    const userAccount = (0, import_common64.toAddress)(new import_web343.PublicKey(pubkeyBytes));
     if (isZeroPubkey2(userAccount))
       throw new Error("Registered external position has a zero address");
     if (results.some((slot) => slot.userAccount === userAccount)) continue;
@@ -24469,7 +25272,7 @@ var ExternalLiquidityIntegrityService = class {
       const decimals = Number(holding.decimals ?? 0);
       const minRaw = toRawAmount(minAmountUi, decimals);
       let targetLocalAmount;
-      if (mintAddress === import_common62.USDC_MINT) {
+      if (mintAddress === import_common64.USDC_MINT) {
         const tvl = toBigInt3(vaultState.accounting.tvl);
         const price = toBigInt3(holding.price);
         const stalenessThreshold = Number(toBigInt3(vaultState.config.priceStalenessThresholdSecs)) || DEFAULT_PRICE_STALENESS_THRESHOLD_SECS;
@@ -24572,25 +25375,25 @@ var ExternalLiquidityIntegrityService = class {
    * from vault accounting as though it were the balance of each separate slot. */
   async loadPositions(vault, mint, slots) {
     const marginfi = (0, import_marginfi5.marginfiAccountsForMint)(mint);
-    if (!marginfi && mint !== import_common62.USDC_MINT)
+    if (!marginfi && mint !== import_common64.USDC_MINT)
       return {
         local: 0n,
         positions: [],
-        tokenProgram: (0, import_kit22.address)(import_web341.PublicKey.default.toBase58()),
-        vaultAta: (0, import_kit22.address)(import_web341.PublicKey.default.toBase58())
+        tokenProgram: (0, import_kit22.address)(import_web343.PublicKey.default.toBase58()),
+        vaultAta: (0, import_kit22.address)(import_web343.PublicKey.default.toBase58())
       };
     const connection = this.client.provider.connection;
     const mintInfo = await connection.getAccountInfo(
-      new import_web341.PublicKey(mint),
+      new import_web343.PublicKey(mint),
       "confirmed"
     );
     if (!mintInfo) throw new Error(`Missing mint ${mint}`);
-    const tokenProgram = (0, import_common62.fromWeb3Pk)(mintInfo.owner);
-    const vaultAta = (0, import_common62.getAtaAddress)(mint, vault, tokenProgram, true);
+    const tokenProgram = (0, import_common64.fromWeb3Pk)(mintInfo.owner);
+    const vaultAta = (0, import_common64.getAtaAddress)(mint, vault, tokenProgram, true);
     const positions = [];
     for (const slot of slots) {
       if (slot.source === "marginfi" && !marginfi) continue;
-      if (slot.source === "kamino" && mint !== import_common62.USDC_MINT) continue;
+      if (slot.source === "kamino" && mint !== import_common64.USDC_MINT) continue;
       const kamino = slot.source === "kamino" ? await loadKaminoDeposit({
         connection,
         vault,
@@ -24601,7 +25404,7 @@ var ExternalLiquidityIntegrityService = class {
         throw new Error("Kamino token program mismatch");
       const data = Buffer.alloc(256);
       data[0] = slot.source === "marginfi" ? 1 : 2;
-      new import_web341.PublicKey(slot.userAccount).toBuffer().copy(data, 8);
+      new import_web343.PublicKey(slot.userAccount).toBuffer().copy(data, 8);
       const withdrawal = await loadWithdrawalPosition({
         connection,
         vault,
@@ -24637,8 +25440,8 @@ var ExternalLiquidityIntegrityService = class {
   async executeMoves(args) {
     const { vault, mintAddress, hwManager, snapshot: snapshot2, moves, dryRun, log } = args;
     const instructions2 = [
-      (0, import_common62.toKitInstruction)(
-        import_web341.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 })
+      (0, import_common64.toKitInstruction)(
+        import_web343.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 })
       )
     ];
     const lookupTables = /* @__PURE__ */ new Set();
@@ -24651,7 +25454,7 @@ var ExternalLiquidityIntegrityService = class {
         cpiRefs = position.withdrawal.explicitRefs(move.amount);
       } else if (position.source === "kamino") {
         if (!position.kamino) throw new Error("Missing Kamino reserve");
-        cpiRefs = (0, import_common62.createCpiRefs)(
+        cpiRefs = (0, import_common64.createCpiRefs)(
           (0, import_kamino5.kaminoDepositCpis)({
             ...position.kamino,
             vault,
@@ -24662,14 +25465,14 @@ var ExternalLiquidityIntegrityService = class {
         );
       } else {
         const configured = (0, import_marginfi5.marginfiAccountsForMint)(mintAddress);
-        cpiRefs = (0, import_common62.createCpiRefs)([
+        cpiRefs = (0, import_common64.createCpiRefs)([
           new import_marginfi5.CpiClient({ accounts: configured }).deposit_cpi({
             marginfiAccount: position.userAccount,
             authority: vault,
             signerTokenAccount: snapshot2.vaultAta,
             amount: move.amount,
-            lookupTables: (import_marginfi_client_v23.ADDRESS_LOOKUP_TABLE_FOR_GROUP[configured.group] ?? []).map(import_common62.fromWeb3Pk),
-            remainingAccounts: configured.tokenProgram === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" ? [(0, import_common62.toCustomAccountMeta)(mintAddress)] : []
+            lookupTables: (import_marginfi_client_v23.ADDRESS_LOOKUP_TABLE_FOR_GROUP[configured.group] ?? []).map(import_common64.fromWeb3Pk),
+            remainingAccounts: configured.tokenProgram === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" ? [(0, import_common64.toCustomAccountMeta)(mintAddress)] : []
           })
         ]);
       }
@@ -24677,7 +25480,7 @@ var ExternalLiquidityIntegrityService = class {
       instructions2.push(
         await this.client.tx.protocolInteraction.getIx({
           vault,
-          hwManager: (0, import_common62.fromWeb3Pk)(hwManager.publicKey),
+          hwManager: (0, import_common64.fromWeb3Pk)(hwManager.publicKey),
           ...cpiRefs,
           externalLiquidityIndex: position.index,
           affectedAssetMint: mintAddress,
@@ -24709,10 +25512,10 @@ var ExternalLiquidityIntegrityService = class {
 
 // src/services/idleLiquidityService.ts
 var import_kit23 = require("@solana/kit");
-var import_spl_token24 = require("@solana/spl-token");
+var import_spl_token26 = require("@solana/spl-token");
 var import_marginfi_client_v24 = require("@mrgnlabs/marginfi-client-v2");
-var import_web342 = require("@solana/web3.js");
-var import_common63 = __toESM(require_dist());
+var import_web344 = require("@solana/web3.js");
+var import_common65 = __toESM(require_dist());
 var import_marginfi6 = __toESM(require_dist2());
 var IDLE_RESERVE_FLOOR_BPS = 400;
 var IDLE_RESERVE_TARGET_BPS = 500;
@@ -24816,8 +25619,8 @@ var IdleLiquidityService = class {
         );
       }
       quote = await jupiter.getQuote({
-        inputMint: import_common63.PST_MINT,
-        outputMint: import_common63.USDC_MINT,
+        inputMint: import_common65.PST_MINT,
+        outputMint: import_common65.USDC_MINT,
         amount: pstInput,
         slippageBps
       });
@@ -24862,13 +25665,13 @@ var IdleLiquidityService = class {
   /** Read live local, Project0 and Kamino USDC, excluding other deployed capital. */
   async fetchIdleUsdc(vault, vaultState) {
     const connection = this.client.provider.connection;
-    const vaultPk = new import_web342.PublicKey(vault);
-    const usdcMint = new import_web342.PublicKey(import_common63.USDC_MINT);
-    const ata = (0, import_spl_token24.getAssociatedTokenAddressSync)(usdcMint, vaultPk, true);
+    const vaultPk = new import_web344.PublicKey(vault);
+    const usdcMint = new import_web344.PublicKey(import_common65.USDC_MINT);
+    const ata = (0, import_spl_token26.getAssociatedTokenAddressSync)(usdcMint, vaultPk, true);
     const tokenInfo = await connection.getAccountInfo(ata, "confirmed");
     let localAmount = 0n;
     if (tokenInfo) {
-      const tokenAccount = (0, import_spl_token24.unpackAccount)(ata, tokenInfo, import_spl_token24.TOKEN_PROGRAM_ID);
+      const tokenAccount = (0, import_spl_token26.unpackAccount)(ata, tokenInfo, import_spl_token26.TOKEN_PROGRAM_ID);
       if (!tokenAccount.mint.equals(usdcMint) || !tokenAccount.owner.equals(vaultPk) || !tokenAccount.isInitialized) {
         throw new Error(`Invalid vault USDC token account: ${ata.toBase58()}`);
       }
@@ -24877,7 +25680,7 @@ var IdleLiquidityService = class {
     const kamino = await this.fetchKaminoUsdc(
       vault,
       vaultState,
-      (0, import_common63.fromWeb3Pk)(ata)
+      (0, import_common65.fromWeb3Pk)(ata)
     );
     const slotIndex = vaultState.externalLiquidity.findIndex(
       (slot) => slot.data[0] === 1
@@ -24895,12 +25698,12 @@ var IdleLiquidityService = class {
     if (data.length < 40) {
       throw new Error(`Invalid Project0 external-liquidity slot ${slotIndex}`);
     }
-    const positionPk = new import_web342.PublicKey(new Uint8Array(data.slice(8, 40)));
+    const positionPk = new import_web344.PublicKey(new Uint8Array(data.slice(8, 40)));
     const positionInfo = await connection.getAccountInfo(
       positionPk,
       "confirmed"
     );
-    if (!positionInfo || !positionInfo.owner.equals(new import_web342.PublicKey(import_marginfi6.MARGINFI_PROGRAM_ID))) {
+    if (!positionInfo || !positionInfo.owner.equals(new import_web344.PublicKey(import_marginfi6.MARGINFI_PROGRAM_ID))) {
       throw new Error(
         `Invalid Project0 slot-${slotIndex} account: ${positionPk.toBase58()}`
       );
@@ -24949,17 +25752,17 @@ var IdleLiquidityService = class {
       if (slot.data[0] !== 2) continue;
       if (slot.data.length < 40)
         throw new Error(`Invalid Kamino external-liquidity slot ${index}`);
-      const key = new import_web342.PublicKey(Uint8Array.from(slot.data.slice(8, 40)));
-      if (key.equals(import_web342.PublicKey.default))
+      const key = new import_web344.PublicKey(Uint8Array.from(slot.data.slice(8, 40)));
+      if (key.equals(import_web344.PublicKey.default))
         throw new Error(`Missing Kamino position in slot ${index}`);
       if (seen.has(key.toBase58())) continue;
       seen.add(key.toBase58());
       const position = await loadWithdrawalPosition({
         connection: this.client.provider.connection,
         vault,
-        assetMint: import_common63.USDC_MINT,
+        assetMint: import_common65.USDC_MINT,
         vaultAssetAta,
-        tokenProgram: (0, import_common63.fromWeb3Pk)(import_spl_token24.TOKEN_PROGRAM_ID),
+        tokenProgram: (0, import_common65.fromWeb3Pk)(import_spl_token26.TOKEN_PROGRAM_ID),
         slot,
         index,
         requireUsablePosition: true
@@ -25010,8 +25813,8 @@ var IdleLiquidityService = class {
       log(`Vault ${vault}: ${reason} \u2014 skipping`);
       return { result: { ...empty, status: "no-tvl", reason } };
     }
-    const usdc = findHolding2(vaultState, import_common63.USDC_MINT);
-    const pst = findHolding2(vaultState, import_common63.PST_MINT);
+    const usdc = findHolding2(vaultState, import_common65.USDC_MINT);
+    const pst = findHolding2(vaultState, import_common65.PST_MINT);
     if (!usdc || !pst) {
       const reason = `vault has no ${usdc ? "PST" : "USDC"} holding`;
       log(`Vault ${vault}: ${reason} \u2014 skipping`);
@@ -25162,16 +25965,16 @@ var IdleLiquidityService = class {
    */
   async mintTokenProgram(mint) {
     const account = await this.client.provider.connection.getAccountInfo(
-      new import_web342.PublicKey(mint),
+      new import_web344.PublicKey(mint),
       "confirmed"
     );
     if (!account) throw new Error(`Mint account not found: ${mint}`);
-    if (!account.owner.equals(import_spl_token24.TOKEN_PROGRAM_ID) && !account.owner.equals(import_spl_token24.TOKEN_2022_PROGRAM_ID)) {
+    if (!account.owner.equals(import_spl_token26.TOKEN_PROGRAM_ID) && !account.owner.equals(import_spl_token26.TOKEN_2022_PROGRAM_ID)) {
       throw new Error(
         `Unsupported token program ${account.owner.toBase58()} for mint ${mint}`
       );
     }
-    return (0, import_common63.fromWeb3Pk)(account.owner);
+    return (0, import_common65.fromWeb3Pk)(account.owner);
   }
   /**
    * Build, simulate, and (unless `dryRun`) submit the `jupiter_swap`.
@@ -25191,23 +25994,23 @@ var IdleLiquidityService = class {
       dryRun,
       log
     } = params;
-    const signer = (0, import_common63.fromWeb3Pk)(hwManager.publicKey);
+    const signer = (0, import_common65.fromWeb3Pk)(hwManager.publicKey);
     const [sourceTokenProgram, destinationTokenProgram] = await Promise.all([
-      this.mintTokenProgram(import_common63.PST_MINT),
-      this.mintTokenProgram(import_common63.USDC_MINT)
+      this.mintTokenProgram(import_common65.PST_MINT),
+      this.mintTokenProgram(import_common65.USDC_MINT)
     ]);
     const jupiterCpi = await jupiter.getSwapCpiData(quote, vault, {
       payer: signer
     });
-    const { accounts: accounts2, refs, lookupTables } = (0, import_common63.createCpiRefs)([jupiterCpi]);
+    const { accounts: accounts2, refs, lookupTables } = (0, import_common65.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_common63.PST_MINT,
-      destinationMint: import_common63.USDC_MINT,
+      sourceMint: import_common65.PST_MINT,
+      destinationMint: import_common65.USDC_MINT,
       refs,
       accounts: accounts2,
       sourceTokenProgram,
@@ -25217,26 +26020,26 @@ var IdleLiquidityService = class {
     });
     const connection = this.client.provider.connection;
     const instructions2 = [
-      import_web342.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNIT_LIMIT }),
+      import_web344.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNIT_LIMIT }),
       ...cuPriceMicroLamports > 0 ? [
-        import_web342.ComputeBudgetProgram.setComputeUnitPrice({
+        import_web344.ComputeBudgetProgram.setComputeUnitPrice({
           microLamports: cuPriceMicroLamports
         })
       ] : [],
-      ...(jupiterCpi.preInstructions ?? []).map(import_common63.fromKitInstruction),
-      ...plan.instructions.map(import_common63.fromKitInstruction)
+      ...(jupiterCpi.preInstructions ?? []).map(import_common65.fromKitInstruction),
+      ...plan.instructions.map(import_common65.fromKitInstruction)
     ];
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-    const lookupTableAccounts = await (0, import_common63.fetchLookupTables)(
+    const lookupTableAccounts = await (0, import_common65.fetchLookupTables)(
       connection,
       plan.lookupTables ?? []
     );
-    const message2 = new import_web342.TransactionMessage({
+    const message2 = new import_web344.TransactionMessage({
       payerKey: hwManager.publicKey,
       recentBlockhash: blockhash,
       instructions: instructions2
     }).compileToV0Message(lookupTableAccounts);
-    const transaction = new import_web342.VersionedTransaction(message2);
+    const transaction = new import_web344.VersionedTransaction(message2);
     transaction.sign([hwManager]);
     if (!this.client.skipSimulation) {
       const simulation = await connection.simulateTransaction(transaction, {
@@ -25282,9 +26085,9 @@ var IdleLiquidityService = class {
 
 // src/services/timelockSettlementService.ts
 var import_kit24 = require("@solana/kit");
-var import_web343 = require("@solana/web3.js");
-var import_common64 = __toESM(require_dist());
-var ZERO_PUBKEY = import_web343.PublicKey.default.toBase58();
+var import_web345 = require("@solana/web3.js");
+var import_common66 = __toESM(require_dist());
+var ZERO_PUBKEY = import_web345.PublicKey.default.toBase58();
 var CONSENSUS_SIGNER_CAPACITY = 4;
 var CONSENSUS_ENTRY_OFFSET = 40;
 var CONSENSUS_ENTRY_SIZE = 272;
@@ -25324,7 +26127,7 @@ function decodePendingConsensusSigners(data) {
   const signers = [];
   for (let i = 0; i < count; i += 1) {
     const start = CONSENSUS_PENDING_OFFSET + i * 32;
-    const signer = new import_web343.PublicKey(bytes.slice(start, start + 32)).toBase58();
+    const signer = new import_web345.PublicKey(bytes.slice(start, start + 32)).toBase58();
     if (signer === ZERO_PUBKEY) {
       throw new Error(`pending consensus signer ${i} is unset`);
     }
@@ -25380,7 +26183,7 @@ var TimelockSettlementService = class {
     });
     const dryRun = opts.dryRun ?? false;
     const now = opts.now ?? await this.chainTime();
-    const fulfillerAddress = (0, import_common64.fromWeb3Pk)(fulfiller.publicKey);
+    const fulfillerAddress = (0, import_common66.fromWeb3Pk)(fulfiller.publicKey);
     const allVaults = opts.vault ? [
       {
         publicKey: opts.vault,
@@ -25523,18 +26326,18 @@ var TimelockSettlementService = class {
 
 // src/services/nestWithdrawalService.ts
 var import_kit25 = require("@solana/kit");
-var import_spl_token25 = require("@solana/spl-token");
-var import_web344 = require("@solana/web3.js");
-var import_common65 = __toESM(require_dist());
+var import_spl_token27 = require("@solana/spl-token");
+var import_web346 = require("@solana/web3.js");
+var import_common67 = __toESM(require_dist());
 var import_nest3 = __toESM(require_dist4());
 var import_nest4 = __toESM(require_dist4());
-var NestOftProgram = new import_web344.PublicKey(
+var NestOftProgram = new import_web346.PublicKey(
   "ChEfPd3RzLeYiRwp1K9evimmaFSd6DV1S4Mv5q5Aj1th"
 );
-var NestOftStore = new import_web344.PublicKey(
+var NestOftStore = new import_web346.PublicKey(
   "k8mJj8Gyw2gFAqut21AFVUUZhxb4RVDMnb4PrSYiDhV"
 );
-var UsdcMint = new import_web344.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var UsdcMint = new import_web346.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 var NestPerenaComposer = Buffer.from(
   "000000000000000000000000908dcb5531691c2124c54e30bb645cf11647090d",
   "hex"
@@ -25551,7 +26354,7 @@ async function buildNestWithdrawalRequest(args) {
   return decodeNestWithdrawalRequest({ ...args, txBase64 });
 }
 async function decodeNestWithdrawalRequest(args) {
-  const transaction = import_web344.VersionedTransaction.deserialize(
+  const transaction = import_web346.VersionedTransaction.deserialize(
     Buffer.from(args.txBase64, "base64")
   );
   const message2 = transaction.message;
@@ -25572,19 +26375,19 @@ async function decodeNestWithdrawalRequest(args) {
       return value;
     })
   );
-  const decoded = import_web344.TransactionMessage.decompile(message2, {
+  const decoded = import_web346.TransactionMessage.decompile(message2, {
     addressLookupTableAccounts: tables
   });
-  const nestMint = new import_web344.PublicKey(NEST_RWA_SHARE_MINT);
-  const sourceAta = (0, import_spl_token25.getAssociatedTokenAddressSync)(nestMint, args.owner, true);
-  const usdcAta = (0, import_spl_token25.getAssociatedTokenAddressSync)(UsdcMint, args.owner, true);
+  const nestMint = new import_web346.PublicKey(NEST_RWA_SHARE_MINT);
+  const sourceAta = (0, import_spl_token27.getAssociatedTokenAddressSync)(nestMint, args.owner, true);
+  const usdcAta = (0, import_spl_token27.getAssociatedTokenAddressSync)(UsdcMint, args.owner, true);
   const instructions2 = decoded.instructions.filter(
-    (ix) => !ix.programId.equals(import_web344.ComputeBudgetProgram.programId)
+    (ix) => !ix.programId.equals(import_web346.ComputeBudgetProgram.programId)
   );
   let sends = 0;
   for (const ix of instructions2) {
-    if (ix.programId.equals(import_spl_token25.ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      if (ix.data.length !== 1 || ix.data[0] !== 1 || !ix.keys[0]?.pubkey.equals(args.owner) || !ix.keys[1]?.pubkey.equals(usdcAta) || !ix.keys[2]?.pubkey.equals(args.owner) || !ix.keys[3]?.pubkey.equals(UsdcMint) || !ix.keys[5]?.pubkey.equals(import_spl_token25.TOKEN_PROGRAM_ID)) {
+    if (ix.programId.equals(import_spl_token27.ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      if (ix.data.length !== 1 || ix.data[0] !== 1 || !ix.keys[0]?.pubkey.equals(args.owner) || !ix.keys[1]?.pubkey.equals(usdcAta) || !ix.keys[2]?.pubkey.equals(args.owner) || !ix.keys[3]?.pubkey.equals(UsdcMint) || !ix.keys[5]?.pubkey.equals(import_spl_token27.TOKEN_PROGRAM_ID)) {
         throw new Error("Unexpected token account creation in Nest withdrawal");
       }
       continue;
@@ -25601,20 +26404,20 @@ async function decodeNestWithdrawalRequest(args) {
   if (sends !== 1)
     throw new Error("Nest withdrawal must contain exactly one OFT send");
   return {
-    instructions: instructions2.map(import_common65.toKitInstruction),
+    instructions: instructions2.map(import_common67.toKitInstruction),
     lookupTables: tables.map((table) => (0, import_kit25.address)(table.key.toBase58()))
   };
 }
 
 // src/services/nestDepositService.ts
 var import_kit26 = require("@solana/kit");
-var import_spl_token26 = require("@solana/spl-token");
-var import_web345 = require("@solana/web3.js");
-var import_common66 = __toESM(require_dist());
+var import_spl_token28 = require("@solana/spl-token");
+var import_web347 = require("@solana/web3.js");
+var import_common68 = __toESM(require_dist());
 var import_nest5 = __toESM(require_dist4());
-var Usdc = new import_web345.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-var Messenger = new import_web345.PublicKey("CCTPV2vPZJS2u2BBsUoscuikbYjnpFmbFsvVuJdgUMQe");
-var Transmitter = new import_web345.PublicKey(
+var Usdc = new import_web347.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var Messenger = new import_web347.PublicKey("CCTPV2vPZJS2u2BBsUoscuikbYjnpFmbFsvVuJdgUMQe");
+var Transmitter = new import_web347.PublicKey(
   "CCTPV2Sm4AdWt5296sk4P66VBZ7bEhcARwFaaS9YPbeC"
 );
 var Router = Buffer.from(
@@ -25667,7 +26470,7 @@ async function decodeNestDepositRequest(args) {
       "Nest deposit must be a positive, safely representable USDC base-unit amount"
     );
   }
-  const message2 = import_web345.VersionedTransaction.deserialize(
+  const message2 = import_web347.VersionedTransaction.deserialize(
     Buffer.from(args.txBase64, "base64")
   ).message;
   if (!message2.staticAccountKeys[0].equals(args.owner))
@@ -25682,23 +26485,23 @@ async function decodeNestDepositRequest(args) {
       return value;
     })
   );
-  const instructions2 = import_web345.TransactionMessage.decompile(message2, {
+  const instructions2 = import_web347.TransactionMessage.decompile(message2, {
     addressLookupTableAccounts: tables
   }).instructions;
-  const shareMint = new import_web345.PublicKey(NEST_RWA_SHARE_MINT);
-  const shareAta = (0, import_spl_token26.getAssociatedTokenAddressSync)(shareMint, args.owner, true);
-  const usdcAta = (0, import_spl_token26.getAssociatedTokenAddressSync)(Usdc, args.owner, true);
+  const shareMint = new import_web347.PublicKey(NEST_RWA_SHARE_MINT);
+  const shareAta = (0, import_spl_token28.getAssociatedTokenAddressSync)(shareMint, args.owner, true);
+  const usdcAta = (0, import_spl_token28.getAssociatedTokenAddressSync)(Usdc, args.owner, true);
   let burn;
   for (const ix of instructions2) {
-    if (ix.programId.equals(import_web345.ComputeBudgetProgram.programId)) continue;
-    if (ix.programId.equals(import_spl_token26.ASSOCIATED_TOKEN_PROGRAM_ID)) {
-      if (ix.data.length !== 1 || ix.data[0] !== 1 || !ix.keys[0]?.pubkey.equals(args.owner) || !ix.keys[1]?.pubkey.equals(shareAta) || !ix.keys[2]?.pubkey.equals(args.owner) || !ix.keys[3]?.pubkey.equals(shareMint) || !ix.keys[4]?.pubkey.equals(import_web345.SystemProgram.programId) || !ix.keys[5]?.pubkey.equals(import_spl_token26.TOKEN_PROGRAM_ID))
+    if (ix.programId.equals(import_web347.ComputeBudgetProgram.programId)) continue;
+    if (ix.programId.equals(import_spl_token28.ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      if (ix.data.length !== 1 || ix.data[0] !== 1 || !ix.keys[0]?.pubkey.equals(args.owner) || !ix.keys[1]?.pubkey.equals(shareAta) || !ix.keys[2]?.pubkey.equals(args.owner) || !ix.keys[3]?.pubkey.equals(shareMint) || !ix.keys[4]?.pubkey.equals(import_web347.SystemProgram.programId) || !ix.keys[5]?.pubkey.equals(import_spl_token28.TOKEN_PROGRAM_ID))
         throw new Error("Unexpected Nest deposit token account creation");
       continue;
     }
     const d = ix.data;
     const matches = (index, key) => ix.keys[index]?.pubkey.equals(key);
-    if (burn || !ix.programId.equals(Messenger) || ix.keys.length !== 18 || d.length < 316 || !d.subarray(0, 8).equals(BurnWithHook) || d.readBigUInt64LE(8) !== args.rawAmountUsdc || d.readUInt32LE(16) !== 22 || !d.subarray(20, 52).equals(Router) || !d.subarray(52, 84).equals(Router) || d.readBigUInt64LE(84) !== 0n || d.readUInt32LE(92) !== 2e3 || d.readUInt32LE(96) !== d.length - 100 || !d.subarray(100, 120).equals(Composer) || !d.subarray(120, 124).equals(MintAndSend) || !d.subarray(124, 156).equals(PerenaAssetId) || BigInt(`0x${d.subarray(156, 188).toString("hex")}`) !== args.rawAmountUsdc || BigInt(`0x${d.subarray(188, 220).toString("hex")}`) !== 128n || !d.subarray(220, 252).equals(Buffer.concat([Buffer.alloc(12), Composer])) || BigInt(`0x${d.subarray(252, 284).toString("hex")}`) !== 30168n || !d.subarray(284, 316).equals(args.owner.toBuffer()) || !matches(0, args.owner) || !matches(3, usdcAta) || !matches(10, Usdc) || !matches(12, Transmitter) || !matches(13, Messenger) || !matches(14, import_spl_token26.TOKEN_PROGRAM_ID) || !matches(15, import_web345.SystemProgram.programId) || !matches(17, Messenger) || ![0, 1, 11].every((index) => ix.keys[index].isSigner) || ix.keys.some(
+    if (burn || !ix.programId.equals(Messenger) || ix.keys.length !== 18 || d.length < 316 || !d.subarray(0, 8).equals(BurnWithHook) || d.readBigUInt64LE(8) !== args.rawAmountUsdc || d.readUInt32LE(16) !== 22 || !d.subarray(20, 52).equals(Router) || !d.subarray(52, 84).equals(Router) || d.readBigUInt64LE(84) !== 0n || d.readUInt32LE(92) !== 2e3 || d.readUInt32LE(96) !== d.length - 100 || !d.subarray(100, 120).equals(Composer) || !d.subarray(120, 124).equals(MintAndSend) || !d.subarray(124, 156).equals(PerenaAssetId) || BigInt(`0x${d.subarray(156, 188).toString("hex")}`) !== args.rawAmountUsdc || BigInt(`0x${d.subarray(188, 220).toString("hex")}`) !== 128n || !d.subarray(220, 252).equals(Buffer.concat([Buffer.alloc(12), Composer])) || BigInt(`0x${d.subarray(252, 284).toString("hex")}`) !== 30168n || !d.subarray(284, 316).equals(args.owner.toBuffer()) || !matches(0, args.owner) || !matches(3, usdcAta) || !matches(10, Usdc) || !matches(12, Transmitter) || !matches(13, Messenger) || !matches(14, import_spl_token28.TOKEN_PROGRAM_ID) || !matches(15, import_web347.SystemProgram.programId) || !matches(17, Messenger) || ![0, 1, 11].every((index) => ix.keys[index].isSigner) || ix.keys.some(
       (meta, index) => meta.isSigner && ![0, 1, 11].includes(index)
     )) {
       throw new Error(
@@ -25717,33 +26520,33 @@ async function decodeNestDepositRequest(args) {
   burn.keys[1] = { pubkey: args.owner, isSigner: true, isWritable: true };
   return {
     instructions: [
-      (0, import_spl_token26.createAssociatedTokenAccountIdempotentInstruction)(
+      (0, import_spl_token28.createAssociatedTokenAccountIdempotentInstruction)(
         args.owner,
         shareAta,
         args.owner,
         shareMint
       ),
       burn
-    ].map(import_common66.toKitInstruction),
+    ].map(import_common68.toKitInstruction),
     lookupTables: tables.map((table) => (0, import_kit26.address)(table.key.toBase58())),
     ephemeralSignerKeys: [eventKey]
   };
 }
 
 // src/services/vaultLutManager.ts
-var import_web346 = require("@solana/web3.js");
+var import_web348 = require("@solana/web3.js");
 var MAX_LUT_ADDRESSES = 256;
 var ACTIVE = (1n << 64n) - 1n;
 var asAddress = (key) => key.toBase58();
 function uniqueLutAddresses(addresses) {
-  return [...new Set(addresses)].filter((a) => a !== import_web346.PublicKey.default.toBase58()).map((a) => asAddress(new import_web346.PublicKey(a)));
+  return [...new Set(addresses)].filter((a) => a !== import_web348.PublicKey.default.toBase58()).map((a) => asAddress(new import_web348.PublicKey(a)));
 }
 var VaultLutManager = class {
   constructor(connection) {
     this.connection = connection;
   }
   async fetch(table) {
-    const account = (await this.connection.getAddressLookupTable(new import_web346.PublicKey(table), {
+    const account = (await this.connection.getAddressLookupTable(new import_web348.PublicKey(table), {
       commitment: "confirmed"
     })).value;
     if (!account) throw new Error(`Lookup table not found: ${table}`);
@@ -25755,14 +26558,14 @@ var VaultLutManager = class {
    * mapping is lost. Also accepts older tables containing the vault elsewhere. */
   async findForVault(authority, vault) {
     const accounts2 = await this.connection.getProgramAccounts(
-      import_web346.AddressLookupTableProgram.programId,
+      import_web348.AddressLookupTableProgram.programId,
       {
         commitment: "confirmed",
         filters: [{ memcmp: { offset: 22, bytes: authority.toBase58() } }]
       }
     );
     return accounts2.flatMap(({ pubkey: pubkey2, account }) => {
-      const state = import_web346.AddressLookupTableAccount.deserialize(account.data);
+      const state = import_web348.AddressLookupTableAccount.deserialize(account.data);
       return state.deactivationSlot === ACTIVE && state.authority?.equals(authority) && state.addresses.some((a) => a.toBase58() === vault) ? [asAddress(pubkey2)] : [];
     });
   }
@@ -25794,7 +26597,7 @@ var VaultLutManager = class {
     let created = false;
     const send = async (instructions2) => {
       const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash("confirmed");
-      const tx = new import_web346.Transaction({
+      const tx = new import_web348.Transaction({
         feePayer: args.payer.publicKey,
         blockhash,
         lastValidBlockHeight
@@ -25821,7 +26624,7 @@ var VaultLutManager = class {
     };
     if (!table) {
       const hashes = await this.connection.getAccountInfo(
-        import_web346.SYSVAR_SLOT_HASHES_PUBKEY,
+        import_web348.SYSVAR_SLOT_HASHES_PUBKEY,
         "confirmed"
       );
       if (!hashes || hashes.data.length < 48 || hashes.data.readBigUInt64LE(0) === 0n)
@@ -25829,7 +26632,7 @@ var VaultLutManager = class {
       const recentSlot = Number(hashes.data.readBigUInt64LE(8));
       if (!Number.isSafeInteger(recentSlot))
         throw new Error("Recent slot exceeds safe integer range");
-      const [create, key] = import_web346.AddressLookupTableProgram.createLookupTable({
+      const [create, key] = import_web348.AddressLookupTableProgram.createLookupTable({
         authority: authority.publicKey,
         payer: args.payer.publicKey,
         recentSlot
@@ -25844,11 +26647,11 @@ var VaultLutManager = class {
       args.onProgress?.(`Creating vault LUT: ${table}`);
       await send([
         create,
-        import_web346.AddressLookupTableProgram.extendLookupTable({
+        import_web348.AddressLookupTableProgram.extendLookupTable({
           lookupTable: key,
           authority: authority.publicKey,
           payer: args.payer.publicKey,
-          addresses: [new import_web346.PublicKey(args.vault)]
+          addresses: [new import_web348.PublicKey(args.vault)]
         })
       ]);
       created = true;
@@ -25868,11 +26671,11 @@ var VaultLutManager = class {
     for (let i = 0; i < missing.length; i += 20) {
       const batch = missing.slice(i, i + 20);
       await send([
-        import_web346.AddressLookupTableProgram.extendLookupTable({
-          lookupTable: new import_web346.PublicKey(table),
+        import_web348.AddressLookupTableProgram.extendLookupTable({
+          lookupTable: new import_web348.PublicKey(table),
           authority: authority.publicKey,
           payer: args.payer.publicKey,
-          addresses: batch.map((a) => new import_web346.PublicKey(a))
+          addresses: batch.map((a) => new import_web348.PublicKey(a))
         })
       ]);
       args.onProgress?.(
@@ -25894,13 +26697,13 @@ var VaultLutManager = class {
 };
 
 // src/services/vaultLookupTableAccounts.ts
-var import_core25 = require("@anchor-lang/core");
-var import_web347 = require("@solana/web3.js");
-var import_spl_token27 = require("@solana/spl-token");
+var import_core26 = require("@anchor-lang/core");
+var import_web349 = require("@solana/web3.js");
+var import_spl_token29 = require("@solana/spl-token");
 var import_marginfi_client_v25 = require("@mrgnlabs/marginfi-client-v2");
 var import_Obligation3 = require("@kamino-finance/klend-sdk/dist/@codegen/klend/accounts/Obligation");
 var import_Reserve3 = require("@kamino-finance/klend-sdk/dist/@codegen/klend/accounts/Reserve");
-var import_common67 = __toESM(require_dist());
+var import_common69 = __toESM(require_dist());
 var import_marginfi7 = __toESM(require_dist2());
 var import_kamino6 = __toESM(require_dist3());
 async function collectVaultLookupTableAccounts(client, vault, options = {}) {
@@ -25915,13 +26718,13 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
   const add = (key) => addresses.push(typeof key === "string" ? key : key.toBase58());
   [
     client.program.programId,
-    import_spl_token27.ASSOCIATED_TOKEN_PROGRAM_ID,
-    import_spl_token27.TOKEN_PROGRAM_ID,
-    import_spl_token27.TOKEN_2022_PROGRAM_ID,
-    import_web347.SYSVAR_INSTRUCTIONS_PUBKEY
+    import_spl_token29.ASSOCIATED_TOKEN_PROGRAM_ID,
+    import_spl_token29.TOKEN_PROGRAM_ID,
+    import_spl_token29.TOKEN_2022_PROGRAM_ID,
+    import_web349.SYSVAR_INSTRUCTIONS_PUBKEY
   ].forEach(add);
   const publicKeys = (value) => {
-    if (value instanceof import_web347.PublicKey) {
+    if (value instanceof import_web349.PublicKey) {
       add(value);
       return;
     }
@@ -25940,7 +26743,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
     }
   ];
   const tranche = await client.program.account.vaultTrancheState.fetchNullable(
-    new import_web347.PublicKey(tranchePda)
+    new import_web349.PublicKey(tranchePda)
   );
   if (tranche) {
     publicKeys(tranche.config);
@@ -25960,30 +26763,30 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
     );
   }
   const holdings = state.holdings.filter(
-    (h) => !h.mint.equals(import_web347.PublicKey.default)
+    (h) => !h.mint.equals(import_web349.PublicKey.default)
   );
   for (const h of holdings) {
     const mint = h.mint.toBase58(), program = tokenProgramAddressFromIdlEnum(h.tokenProgram);
     add(mint);
     add(program);
-    add((0, import_common67.getAtaAddress)(mint, vault, program, true));
-    add((0, import_common67.getAtaAddress)(mint, fee, program, true));
-    if (options.user) add((0, import_common67.getAtaAddress)(mint, options.user, program, true));
+    add((0, import_common69.getAtaAddress)(mint, vault, program, true));
+    add((0, import_common69.getAtaAddress)(mint, fee, program, true));
+    if (options.user) add((0, import_common69.getAtaAddress)(mint, options.user, program, true));
   }
   for (const share of shares) {
     add(share.mint);
     add(share.program);
-    add((0, import_common67.getAtaAddress)(share.mint, vault, share.program, true));
-    add((0, import_common67.getAtaAddress)(share.mint, fee, share.program, true));
+    add((0, import_common69.getAtaAddress)(share.mint, vault, share.program, true));
+    add((0, import_common69.getAtaAddress)(share.mint, fee, share.program, true));
     if (options.user)
-      add((0, import_common67.getAtaAddress)(share.mint, options.user, share.program, true));
+      add((0, import_common69.getAtaAddress)(share.mint, options.user, share.program, true));
   }
   const slots = state.externalLiquidity.filter(
     (s) => [1, 2].includes(s.data[0])
   );
   for (const slot of slots) {
-    const position = new import_web347.PublicKey(Uint8Array.from(slot.data.slice(8, 40)));
-    if (position.equals(import_web347.PublicKey.default)) continue;
+    const position = new import_web349.PublicKey(Uint8Array.from(slot.data.slice(8, 40)));
+    if (position.equals(import_web349.PublicKey.default)) continue;
     add(position);
     const info = await connection.getAccountInfo(position, "confirmed");
     if (slot.data[0] === 1) {
@@ -25994,7 +26797,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
         const cpi = new import_marginfi7.CpiClient({ accounts: config }).withdraw_cpi({
           marginfiAccount: position.toBase58(),
           authority: vault,
-          destinationTokenAccount: (0, import_common67.getAtaAddress)(
+          destinationTokenAccount: (0, import_common69.getAtaAddress)(
             mint,
             vault,
             config.tokenProgram,
@@ -26006,7 +26809,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
       if (!info) continue;
       if (info.owner.toBase58() !== import_marginfi7.MARGINFI_PROGRAM_ID)
         throw new Error("Invalid Marginfi position owner");
-      const idl = new import_core25.Program(
+      const idl = new import_core26.Program(
         { ...import_marginfi_client_v25.MARGINFI_IDL, address: import_marginfi7.MARGINFI_PROGRAM_ID },
         { connection }
       ).idl;
@@ -26047,7 +26850,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
       if (!reserveKeys.length)
         throw new Error(`No reserves found for Kamino obligation ${position}`);
       const infos = await connection.getMultipleAccountsInfo(
-        reserveKeys.map((a) => new import_web347.PublicKey(a)),
+        reserveKeys.map((a) => new import_web349.PublicKey(a)),
         "confirmed"
       );
       const reserves = infos.map((info2, i) => {
@@ -26077,7 +26880,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
           obligation: position.toBase58(),
           reserves,
           reserve,
-          destination: (0, import_common67.getAtaAddress)(
+          destination: (0, import_common69.getAtaAddress)(
             reserve.liquidityMint,
             vault,
             reserve.liquidityTokenProgram,
@@ -26097,7 +26900,7 @@ async function collectVaultLookupTableAccounts(client, vault, options = {}) {
 }
 
 // src/index.ts
-var import_common68 = __toESM(require_dist());
+var import_common70 = __toESM(require_dist());
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ASSET_DECIMALS,
@@ -26151,6 +26954,7 @@ var import_common68 = __toESM(require_dist());
   ExternalLiquidityIntegrityService,
   ExternalPositionRegistry,
   FEE_VAULT_CACHE_CATEGORY,
+  FulfillAsyncWithdrawBuilder,
   FulfillJuniorTrancheWithdrawBuilder,
   IDL,
   IDLE_RESERVE_FLOOR_BPS,
@@ -26205,6 +27009,7 @@ var import_common68 = __toESM(require_dist());
   REPORTABLE_ORACLE_VARIANTS,
   RemoveAssetHoldingBuilder,
   ReportIncentiveV3Builder,
+  RequestAsyncWithdrawBuilder,
   RequestJuniorTrancheWithdrawBuilder,
   RpcManagerWalletBalanceSource,
   RpcMpcWalletBalanceSource,
@@ -26249,6 +27054,7 @@ var import_common68 = __toESM(require_dist());
   VaultLutManager,
   VaultQuoteClient,
   VaultReallocationBuilder,
+  WALLET_FEE_EXEMPT_WHITELIST,
   WITHDRAWABLE_RESERVE_FLOOR_BPS,
   WithdrawalQueueService,
   accountingUnitPriceToUsd,
@@ -26347,6 +27153,7 @@ var import_common68 = __toESM(require_dist());
   previousPhysicalNav,
   priceInAccountingUnit,
   publishedConsensusBlockers,
+  quoteWithdrawalPayout,
   readI64LE,
   readSplMintSupply,
   reconcileManagerWalletBalances,