@perena/vault-sdk 1.0.47 → 1.0.48

package/dist/index.js

@@ -149,7 +149,7 @@ var require_compat = __commonJS({
     exports2.fromWeb3PublicKey = fromWeb3PublicKey;
     exports2.toWeb3PublicKey = toWeb3PublicKey;
     exports2.asWeb3PublicKey = asWeb3PublicKey2;
-    exports2.toKitInstruction = toKitInstruction33;
+    exports2.toKitInstruction = toKitInstruction35;
     exports2.fromKitInstruction = fromKitInstruction3;
     var kit_1 = require("@solana/kit");
     var web3_js_1 = require("@solana/web3.js");
@@ -165,7 +165,7 @@ var require_compat = __commonJS({
     exports2.toAddress = fromWeb3PublicKey;
     exports2.fromWeb3Pk = fromWeb3PublicKey;
     exports2.toWeb3Pk = toWeb3PublicKey;
-    function toKitInstruction33(ix) {
+    function toKitInstruction35(ix) {
       return {
         programAddress: ix.programId.toBase58(),
         data: new Uint8Array(ix.data),
@@ -194,10 +194,10 @@ var require_ata = __commonJS({
   "../common/dist/utils/accounts/ata.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getAtaAddress = getAtaAddress19;
+    exports2.getAtaAddress = getAtaAddress20;
     var spl_token_1 = require("@solana/spl-token");
     var compat_1 = require_compat();
-    function getAtaAddress19(mint, owner, tokenProgram, allowOwnerOffCurve = true) {
+    function getAtaAddress20(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();
     }
@@ -2844,12 +2844,12 @@ var require_routePreInstructions = __commonJS({
         if (existingAta.value) {
           continue;
         }
-        instructions2.push(toKitInstruction33((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(new web3_js_1.PublicKey(payer), new web3_js_1.PublicKey(ata), new web3_js_1.PublicKey(user), new web3_js_1.PublicKey(mint), new web3_js_1.PublicKey(tokenProgram), spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID)));
+        instructions2.push(toKitInstruction35((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(new web3_js_1.PublicKey(payer), new web3_js_1.PublicKey(ata), new web3_js_1.PublicKey(user), new web3_js_1.PublicKey(mint), new web3_js_1.PublicKey(tokenProgram), spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID)));
         postSuccessCacheInvalidations.push({ address: ata });
       }
       return { instructions: instructions2, postSuccessCacheInvalidations };
     }
-    function toKitInstruction33(ix) {
+    function toKitInstruction35(ix) {
       return {
         programAddress: ix.programId.toBase58(),
         accounts: ix.keys.map((account) => ({
@@ -3281,16 +3281,19 @@ __export(index_exports, {
   AccountClient: () => AccountClient,
   ActivateCircuitBreakerBuilder: () => ActivateCircuitBreakerBuilder,
   AddIncentiveRecipientBuilder: () => AddIncentiveRecipientBuilder,
+  AddIncentiveRecipientV3Builder: () => AddIncentiveRecipientV3Builder,
   BALANCE_CHANGE_BASELINE_MAX_AGE_SECS: () => BALANCE_CHANGE_BASELINE_MAX_AGE_SECS,
   CONSENSUS_ORACLE_VARIANT: () => CONSENSUS_ORACLE_VARIANT,
   CancelIncentiveProposalBuilder: () => CancelIncentiveProposalBuilder,
   CancelJuniorTrancheWithdrawBuilder: () => CancelJuniorTrancheWithdrawBuilder,
   ClaimIncentiveBuilder: () => ClaimIncentiveBuilder,
+  ClaimIncentiveV3Builder: () => ClaimIncentiveV3Builder,
   ConsensusOracleService: () => ConsensusOracleService,
   CrankNavBuilder: () => CrankNavBuilder,
   CrankPerformanceFeesBuilder: () => CrankPerformanceFeesBuilder,
   CreateAssetHoldingBuilder: () => CreateAssetHoldingBuilder,
   CreateIncentiveBuilder: () => CreateIncentiveBuilder,
+  CreateIncentiveV3Builder: () => CreateIncentiveV3Builder,
   CreateTrancheStateBuilder: () => CreateTrancheStateBuilder,
   CreateVaultBuilder: () => CreateVaultBuilder,
   DEFAULT_CU_PRICE_MICRO_LAMPORTS: () => DEFAULT_CU_PRICE_MICRO_LAMPORTS,
@@ -3299,7 +3302,7 @@ __export(index_exports, {
   DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS: () => DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS,
   DEFAULT_MAX_ACCEPTABLE_APY_BPS: () => DEFAULT_MAX_ACCEPTABLE_APY_BPS,
   DEFAULT_MAX_ACCOUNTS: () => DEFAULT_MAX_ACCOUNTS,
-  DEFAULT_MINTS: () => import_common57.DEFAULT_MINTS,
+  DEFAULT_MINTS: () => import_common60.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,
@@ -3311,6 +3314,7 @@ __export(index_exports, {
   DEFAULT_VAULT_ID: () => DEFAULT_VAULT_ID,
   DisableCircuitBreakerBuilder: () => DisableCircuitBreakerBuilder,
   DistributeIncentiveBuilder: () => DistributeIncentiveBuilder,
+  DistributeIncentiveV3Builder: () => DistributeIncentiveV3Builder,
   EXTERNAL_POSITION_SAMPLES: () => EXTERNAL_POSITION_SAMPLES,
   ExecuteDepositBuilder: () => ExecuteDepositBuilder,
   ExecuteShareSwapBuilder: () => ExecuteShareSwapBuilder,
@@ -3338,13 +3342,14 @@ __export(index_exports, {
   MAX_BALANCE_CHANGE_BPS: () => MAX_BALANCE_CHANGE_BPS,
   MAX_CONSENSUS_SIGNERS: () => MAX_CONSENSUS_SIGNERS,
   MAX_INCENTIVE_RECIPIENTS: () => MAX_INCENTIVE_RECIPIENTS,
+  MAX_INCENTIVE_REPORT_TTL: () => MAX_INCENTIVE_REPORT_TTL,
   MAX_MANAGER_WITHDRAW_DESTINATIONS: () => MAX_MANAGER_WITHDRAW_DESTINATIONS,
   MAX_PRICE_STALENESS_THRESHOLD_SECS: () => MAX_PRICE_STALENESS_THRESHOLD_SECS,
   MIN_EXTERNAL_POSITION_SAMPLES: () => MIN_EXTERNAL_POSITION_SAMPLES,
   ManagerRedepositAssetBuilder: () => ManagerRedepositAssetBuilder,
   ManagerWithdrawAssetBuilder: () => ManagerWithdrawAssetBuilder,
   MarginfiPositionProvider: () => MarginfiPositionProvider,
-  MintRegistry: () => import_common57.MintRegistry,
+  MintRegistry: () => import_common60.MintRegistry,
   MockYieldTracker: () => MockYieldTracker,
   NEST_API_BASE_URL: () => import_nest2.NEST_API_BASE_URL,
   NEST_RWA_SHARE_MINT: () => NEST_RWA_SHARE_MINT,
@@ -3355,7 +3360,7 @@ __export(index_exports, {
   ORACLE_ENTRY_SIZE: () => ORACLE_ENTRY_SIZE,
   ORACLE_SETTLED_NAV_TS_OFFSET: () => ORACLE_SETTLED_NAV_TS_OFFSET,
   OracleService: () => OracleService,
-  PRICE_ORACLE_TYPES_BY_INDEX: () => PRICE_ORACLE_TYPES_BY_INDEX2,
+  PRICE_ORACLE_TYPES_BY_INDEX: () => PRICE_ORACLE_TYPES_BY_INDEX,
   PROGRAM_FEE_EXEMPT_OWNER_WHITELIST: () => PROGRAM_FEE_EXEMPT_OWNER_WHITELIST,
   PROTOCOL_ADMIN: () => PROTOCOL_ADMIN,
   PROTOCOL_FEE_RECIPIENT: () => PROTOCOL_FEE_RECIPIENT,
@@ -3363,15 +3368,18 @@ __export(index_exports, {
   ProtocolInteractionBuilder: () => ProtocolInteractionBuilder,
   REPORTABLE_ORACLE_VARIANTS: () => REPORTABLE_ORACLE_VARIANTS,
   RemoveAssetHoldingBuilder: () => RemoveAssetHoldingBuilder,
+  ReportIncentiveV3Builder: () => ReportIncentiveV3Builder,
   RequestJuniorTrancheWithdrawBuilder: () => RequestJuniorTrancheWithdrawBuilder,
   SHARE_DECIMALS: () => SHARE_DECIMALS,
-  SYSTEM_PROGRAM: () => SYSTEM_PROGRAM2,
+  SYSTEM_PROGRAM: () => SYSTEM_PROGRAM,
   SetAssetPriceOracleBuilder: () => SetAssetPriceOracleBuilder,
   SetExternalLiquidityBuilder: () => SetExternalLiquidityBuilder,
   SetIncentiveLimitsBuilder: () => SetIncentiveLimitsBuilder,
+  SetIncentiveLimitsV3Builder: () => SetIncentiveLimitsV3Builder,
   SetManagerWithdrawDestinationBuilder: () => SetManagerWithdrawDestinationBuilder,
   SetProtocolFeeBuilder: () => SetProtocolFeeBuilder,
   SetVaultConfigBuilder: () => SetVaultConfigBuilder,
+  SettleIncentiveV3Builder: () => SettleIncentiveV3Builder,
   SquadsProposalExecutionSimulationError: () => SquadsProposalExecutionSimulationError,
   StaticPositionProvider: () => StaticPositionProvider,
   SubmitIncentiveBuilder: () => SubmitIncentiveBuilder,
@@ -3448,6 +3456,10 @@ __export(index_exports, {
   getIncentiveRecipients: () => getIncentiveRecipients,
   getIncentiveReportRecipients: () => getIncentiveReportRecipients,
   getIncentiveTotals: () => getIncentiveTotals,
+  getIncentiveV3OracleState: () => getIncentiveV3OracleState,
+  getIncentiveV3RecipientShareAtas: () => getIncentiveV3RecipientShareAtas,
+  getIncentiveV3Recipients: () => getIncentiveV3Recipients,
+  getIncentiveV3Totals: () => getIncentiveV3Totals,
   getNavValue: () => getNavValue,
   getRpcUrl: () => getRpcUrl,
   getTotalOutstandingYield: () => getTotalOutstandingYield,
@@ -3467,7 +3479,7 @@ __export(index_exports, {
   logProspectiveApy: () => logProspectiveApy,
   makeProvider: () => makeProvider,
   mintTokensTo: () => mintTokensTo,
-  mints: () => import_common57.mints,
+  mints: () => import_common60.mints,
   mostFrequent: () => mostFrequent,
   parseExternalLiquidityRefs: () => parseExternalLiquidityRefs,
   planRebalance: () => planRebalance,
@@ -3567,16 +3579,16 @@ var USD_STAR_PRINCIPAL_MINT = (0, import_kit.address)(
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
-var import_core19 = require("@anchor-lang/core");
-var import_web321 = require("@solana/web3.js");
+var import_core20 = require("@anchor-lang/core");
+var import_web323 = require("@solana/web3.js");
 var import_kit10 = require("@solana/kit");
-var import_common40 = __toESM(require_dist());
+var import_common43 = __toESM(require_dist());
 
 // src/client/client.ts
-var import_core18 = require("@anchor-lang/core");
+var import_core19 = require("@anchor-lang/core");
 var import_kit9 = require("@solana/kit");
-var import_web320 = require("@solana/web3.js");
-var import_common39 = __toESM(require_dist());
+var import_web322 = require("@solana/web3.js");
+var import_common42 = __toESM(require_dist());
 
 // src/idl/vault.ts
 var IDL = {
@@ -13644,6 +13656,36 @@ var AccountClient = class extends import_common.BaseAccountClient {
     this.program = program;
     this.pda = pda;
   }
+  /** Always fresh: report sequences, generations, USD and share counters must not be cached. */
+  async fetchIncentiveV3(incentive) {
+    return this.program.account.vaultIncentiveV3.fetch((0, import_common.toWeb3Pk)(incentive));
+  }
+  async fetchIncentiveV3Nullable(incentive) {
+    return this.program.account.vaultIncentiveV3.fetchNullable(
+      (0, import_common.toWeb3Pk)(incentive)
+    );
+  }
+  async fetchIncentiveV3ForVault(vault, id) {
+    const [incentive] = await this.pda.deriveIncentiveV3Pda(vault, id);
+    return this.fetchIncentiveV3(incentive);
+  }
+  /** Fresh batch lookup preserving input order, duplicates, and missing entries. */
+  async fetchIncentivesV3(incentives) {
+    if (incentives.length === 0) return [];
+    return this.program.account.vaultIncentiveV3.fetchMultiple(
+      incentives.map(import_common.toWeb3Pk)
+    );
+  }
+  /** V3 campaigns only; the discriminator excludes legacy share-denominated accounts. */
+  async fetchAllIncentivesV3ForVault(vault) {
+    const accounts2 = await this.program.account.vaultIncentiveV3.all([
+      { memcmp: { offset: 8, bytes: vault } }
+    ]);
+    return accounts2.map(({ publicKey, account }) => ({
+      publicKey: (0, import_common.fromWeb3Pk)(publicKey),
+      account
+    }));
+  }
   /** Always fresh: callers use the proposal round and cumulative entitlements. */
   async fetchIncentive(incentive) {
     return this.program.account.vaultIncentive.fetch((0, import_common.toWeb3Pk)(incentive));
@@ -13820,6 +13862,17 @@ var PdaClient = class {
       seeds: [Buffer.from("incentive"), addressEncoder.encode(vault), bytes]
     });
   }
+  /** Separate V3 namespace: `["incentive_v3", vault, id_u64_le]`. */
+  async deriveIncentiveV3Pda(vault, id) {
+    if (id < 0n || id > 0xffffffffffffffffn)
+      throw new RangeError("Incentive ID must fit u64");
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, id, true);
+    return (0, import_kit3.getProgramDerivedAddress)({
+      programAddress: this.programAddress,
+      seeds: [Buffer.from("incentive_v3"), addressEncoder.encode(vault), bytes]
+    });
+  }
   /**
    * Vault PDA for a global vault id.
    *
@@ -14522,25 +14575,360 @@ var ClaimIncentiveBuilder = class extends VaultBuilderBase {
   }
 };
 
-// src/client/builders/cancelJuniorTrancheWithdraw.ts
-var import_spl_token4 = require("@solana/spl-token");
+// src/client/builders/incentivesV3.ts
+var import_core2 = require("@anchor-lang/core");
 var import_web35 = require("@solana/web3.js");
 var import_common6 = __toESM(require_dist());
-var CancelJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
+var u64 = (value) => {
+  if (value < 0n || value > 0xffffffffffffffffn)
+    throw new RangeError("Incentive value must fit u64");
+  return new import_core2.BN(value.toString());
+};
+function validateIndices(indices) {
+  if (indices.length === 0 || indices.length > MAX_INCENTIVE_RECIPIENTS || new Set(indices).size !== indices.length || indices.some(
+    (index) => !Number.isInteger(index) || index < 0 || index >= MAX_INCENTIVE_RECIPIENTS
+  ))
+    throw new RangeError(
+      "Supply distinct incentive recipient indices from 0 to 4"
+    );
+}
+var CreateIncentiveV3Builder = class extends VaultBuilderBase {
   async getIx(args) {
-    return this.program.methods.cancelJuniorTrancheWithdraw().accountsPartial({
-      user: (0, import_common6.toWeb3Pk)(args.user),
-      payer: (0, import_common6.toWeb3Pk)(args.payer),
+    return this.program.methods.createIncentiveV3({
+      id: u64(args.id),
+      recipients: args.recipients.map(import_common6.toWeb3Pk),
+      maxTotalUsd: u64(args.maxTotalUsd)
+    }).accountsStrict({
+      oracle: (0, import_common6.toWeb3Pk)(args.oracle),
       vault: (0, import_common6.toWeb3Pk)(args.vault),
-      withdrawalQueue: (0, import_common6.toWeb3Pk)(args.withdrawalQueue),
-      inputMint: (0, import_common6.toWeb3Pk)(args.inputMint),
-      userInputAta: (0, import_common6.toWeb3Pk)(args.userInputAta),
-      queueInputAta: (0, import_common6.toWeb3Pk)(args.queueInputAta),
-      shareTokenProgram: (0, import_common6.toWeb3Pk)(args.shareTokenProgram),
-      associatedTokenProgram: import_spl_token4.ASSOCIATED_TOKEN_PROGRAM_ID,
+      vaultOracle: (0, import_common6.toWeb3Pk)(args.vaultOracle),
+      incentive: (0, import_common6.toWeb3Pk)(args.incentive),
       systemProgram: import_web35.SystemProgram.programId
     }).instruction().then(import_common6.toKitInstruction);
   }
+  async deriveIxArgs(args) {
+    const [incentive] = await this.pda.deriveIncentiveV3Pda(
+      args.vault,
+      args.id
+    );
+    const [vaultOracle] = await this.pda.deriveVaultOraclePda(args.vault);
+    return { ...args, incentive, vaultOracle };
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        { vaultPda: args.vault, vaultOraclePda: args.vaultOracle }
+      ]
+    };
+  }
+};
+var AddIncentiveRecipientV3Builder = class extends VaultBuilderBase {
+  async getIx(args) {
+    return this.program.methods.addIncentiveRecipientV3((0, import_common6.toWeb3Pk)(args.wallet)).accountsStrict({
+      oracle: (0, import_common6.toWeb3Pk)(args.oracle),
+      vault: (0, import_common6.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common6.toWeb3Pk)(args.vaultOracle),
+      incentive: (0, import_common6.toWeb3Pk)(args.incentive)
+    }).instruction().then(import_common6.toKitInstruction);
+  }
+  async deriveIxArgs(args) {
+    const [vaultOracle] = await this.pda.deriveVaultOraclePda(args.vault);
+    return { ...args, vaultOracle };
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        { vaultPda: args.vault, vaultOraclePda: args.vaultOracle }
+      ]
+    };
+  }
+};
+var SetIncentiveLimitsV3Builder = class extends VaultBuilderBase {
+  async getIx(args) {
+    return this.program.methods.setIncentiveLimitsV3({
+      maxTotalUsd: u64(args.maxTotalUsd),
+      maxSurplusValue: u64(args.maxSurplusValue),
+      minSurplusReserve: u64(args.minSurplusReserve)
+    }).accountsStrict({
+      curator: (0, import_common6.toWeb3Pk)(args.curator),
+      vault: (0, import_common6.toWeb3Pk)(args.vault),
+      incentive: (0, import_common6.toWeb3Pk)(args.incentive)
+    }).instruction().then(import_common6.toKitInstruction);
+  }
+  async buildPlanExtras(args) {
+    return { postSuccessCacheInvalidations: [{ vaultPda: args.vault }] };
+  }
+};
+var ReportIncentiveV3Builder = class extends VaultBuilderBase {
+  async getIx(args) {
+    validateIndices(args.updates.map((update) => update.recipientIndex));
+    if (args.sequence <= 0n)
+      throw new RangeError("Incentive sequence must be positive");
+    if (args.expiresAt < -0x8000000000000000n || args.expiresAt > 0x7fffffffffffffffn)
+      throw new RangeError("Incentive expiry must fit i64");
+    return this.program.methods.reportIncentiveV3({
+      signerGeneration: u64(args.signerGeneration),
+      configGeneration: u64(args.configGeneration),
+      sequence: u64(args.sequence),
+      expiresAt: new import_core2.BN(args.expiresAt.toString()),
+      updates: args.updates.map((update) => ({
+        recipientIndex: update.recipientIndex,
+        totalUsd: u64(update.totalUsd)
+      }))
+    }).accountsStrict({
+      oracle: (0, import_common6.toWeb3Pk)(args.oracle),
+      vault: (0, import_common6.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common6.toWeb3Pk)(args.vaultOracle),
+      incentive: (0, import_common6.toWeb3Pk)(args.incentive)
+    }).instruction().then(import_common6.toKitInstruction);
+  }
+  async deriveIxArgs(args) {
+    const [vaultOracle] = await this.pda.deriveVaultOraclePda(args.vault);
+    return { ...args, vaultOracle };
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        { vaultPda: args.vault, vaultOraclePda: args.vaultOracle }
+      ]
+    };
+  }
+};
+var SettleIncentiveV3Builder = class extends VaultBuilderBase {
+  async getIx(args) {
+    validateIndices(args.recipientIndices);
+    return this.program.methods.settleIncentiveV3(Buffer.from(args.recipientIndices)).accountsStrict({
+      cranker: (0, import_common6.toWeb3Pk)(args.cranker),
+      vault: (0, import_common6.toWeb3Pk)(args.vault),
+      incentive: (0, import_common6.toWeb3Pk)(args.incentive),
+      vaultOracle: (0, import_common6.toWeb3Pk)(args.vaultOracle),
+      shareMint: (0, import_common6.toWeb3Pk)(args.shareMint),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common6.toWeb3Pk)(args.vaultTrancheState) : null,
+      juniorTrancheShareMint: args.juniorTrancheShareMint ? (0, import_common6.toWeb3Pk)(args.juniorTrancheShareMint) : null,
+      seniorTrancheShareMint: args.seniorTrancheShareMint ? (0, import_common6.toWeb3Pk)(args.seniorTrancheShareMint) : null
+    }).instruction().then(import_common6.toKitInstruction);
+  }
+  async deriveIxArgs(args) {
+    const [vaultOracle] = await this.pda.deriveVaultOraclePda(args.vault);
+    const vault = await this.account.fetchVault(args.vault, { fresh: true });
+    const vaultTrancheState = await resolveVaultTrancheState(
+      this.account,
+      this.pda,
+      args.vault,
+      void 0
+    );
+    const tranche = vaultTrancheState ? await this.account.fetchVaultTrancheState(vaultTrancheState, {
+      fresh: true
+    }) : null;
+    return {
+      ...args,
+      vaultOracle,
+      shareMint: (0, import_common6.fromWeb3Pk)(vault.mint),
+      vaultTrancheState,
+      juniorTrancheShareMint: tranche ? (0, import_common6.fromWeb3Pk)(tranche.config.juniorMint) : null,
+      seniorTrancheShareMint: tranche ? (0, import_common6.fromWeb3Pk)(tranche.config.seniorMint) : null
+    };
+  }
+  async buildPlanExtras(args) {
+    return {
+      postSuccessCacheInvalidations: [
+        {
+          vaultPda: args.vault,
+          vaultOraclePda: args.vaultOracle,
+          vaultTrancheStatePda: args.vaultTrancheState ?? void 0
+        }
+      ]
+    };
+  }
+};
+
+// src/client/builders/incentivesV3Claims.ts
+var import_common8 = __toESM(require_dist());
+
+// src/utils/incentivesV3.ts
+var import_web36 = require("@solana/web3.js");
+var import_common7 = __toESM(require_dist());
+
+// src/services/consensusOracle/constants.ts
+var SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var PRICE_ORACLE_TYPES_BY_INDEX = [
+  "none",
+  "consensusOracle",
+  "pyth",
+  "perenaVault"
+];
+var CONSENSUS_ORACLE_VARIANT = "consensusoracle";
+var LIVE_ORACLE_VARIANTS = /* @__PURE__ */ new Set(["pyth", "perenavault"]);
+var REPORTABLE_ORACLE_VARIANTS = /* @__PURE__ */ new Set([
+  CONSENSUS_ORACLE_VARIANT,
+  ...LIVE_ORACLE_VARIANTS
+]);
+var LIVE_PRICE_REFRESH_INTERVAL_SECS = 60n * 60n;
+var DEFAULT_PRICE_STALENESS_SECS = BigInt(
+  DEFAULT_PRICE_STALENESS_THRESHOLD_SECS
+);
+var EXTERNAL_POSITION_SAMPLES = 5;
+var MIN_EXTERNAL_POSITION_SAMPLES = 4;
+var ORACLE_ENTRY_SIZE = 272;
+var ORACLE_ENTRIES_OFFSET = 40;
+var ORACLE_SETTLED_NAV_TS_OFFSET = 8;
+var MAX_CONSENSUS_SIGNERS = 4;
+
+// src/utils/incentivesV3.ts
+var MAX_INCENTIVE_REPORT_TTL = 86400n;
+function getIncentiveV3OracleState(oracle, now) {
+  const data = Buffer.from(oracle.data);
+  if (!("consensusOracle" in oracle.oracleType) || data.length !== 2048)
+    throw new RangeError(
+      "Expected a consensus oracle with a 2048-byte payload"
+    );
+  const pendingOffset = ORACLE_ENTRIES_OFFSET + MAX_CONSENSUS_SIGNERS * ORACLE_ENTRY_SIZE;
+  const pendingTimestampOffset = pendingOffset + MAX_CONSENSUS_SIGNERS * 32;
+  const pendingCount = data[pendingTimestampOffset + 8];
+  if (pendingCount > MAX_CONSENSUS_SIGNERS)
+    throw new RangeError("Invalid pending oracle signer count");
+  const matured = pendingCount > 0 && data.readBigInt64LE(pendingTimestampOffset) <= now;
+  const signers = [0, 1].map((index) => {
+    if (matured && index >= pendingCount) return (0, import_common7.fromWeb3Pk)(import_web36.PublicKey.default);
+    const offset = matured ? pendingOffset + index * 32 : ORACLE_ENTRIES_OFFSET + index * ORACLE_ENTRY_SIZE;
+    return (0, import_common7.fromWeb3Pk)(new import_web36.PublicKey(data.subarray(offset, offset + 32)));
+  });
+  if (signers.includes((0, import_common7.fromWeb3Pk)(import_web36.PublicKey.default)) || signers[0] === signers[1])
+    throw new RangeError(
+      "Incentives require two distinct nonzero oracle signers"
+    );
+  const signerGeneration = data.readBigUInt64LE(data.length - 8) + (matured ? 1n : 0n);
+  if (signerGeneration > 0xffffffffffffffffn)
+    throw new RangeError("Oracle signer generation overflow");
+  return { signers, signerGeneration };
+}
+function getIncentiveV3Recipients(incentive) {
+  const count = incentive.recipientCount;
+  if (incentive.version !== 3)
+    throw new RangeError("Expected a V3 incentive account");
+  if (!Number.isInteger(count) || count < 0 || count > MAX_INCENTIVE_RECIPIENTS || count > incentive.recipients.length)
+    throw new RangeError("Invalid incentive recipient count");
+  return incentive.recipients.slice(0, count).map((entry, recipientIndex) => {
+    const settledShares = BigInt(entry.settledShares.toString());
+    const claimedShares = BigInt(entry.claimedShares.toString());
+    return {
+      recipientIndex,
+      wallet: (0, import_common7.fromWeb3Pk)(entry.wallet),
+      oracleTotalUsd: [
+        BigInt(entry.oracleTotalUsd[0].toString()),
+        BigInt(entry.oracleTotalUsd[1].toString())
+      ],
+      expiresAt: [
+        BigInt(entry.expiresAt[0].toString()),
+        BigInt(entry.expiresAt[1].toString())
+      ],
+      settledUsd: BigInt(entry.settledUsd.toString()),
+      settledShares,
+      claimedShares,
+      outstandingShares: settledShares - claimedShares
+    };
+  });
+}
+function getIncentiveV3Totals(incentive) {
+  return getIncentiveV3Recipients(incentive).reduce(
+    (totals, recipient) => ({
+      settledUsd: totals.settledUsd + recipient.settledUsd,
+      settledShares: totals.settledShares + recipient.settledShares,
+      claimedShares: totals.claimedShares + recipient.claimedShares,
+      outstandingShares: totals.outstandingShares + recipient.outstandingShares
+    }),
+    {
+      settledUsd: 0n,
+      settledShares: 0n,
+      claimedShares: 0n,
+      outstandingShares: 0n
+    }
+  );
+}
+function getIncentiveV3RecipientShareAtas(incentive, shareMint, shareTokenProgram) {
+  return getIncentiveV3Recipients(incentive).map(
+    ({ wallet }) => (0, import_common7.getAtaAddress)(shareMint, wallet, shareTokenProgram, true)
+  );
+}
+
+// src/client/builders/incentivesV3Claims.ts
+var ClaimIncentiveV3Builder = class extends ClaimIncentiveBuilder {
+  async getIx(args) {
+    return this.program.methods.claimIncentiveV3().accountsStrict({
+      recipient: (0, import_common8.toWeb3Pk)(args.recipient),
+      vault: (0, import_common8.toWeb3Pk)(args.vault),
+      incentive: (0, import_common8.toWeb3Pk)(args.incentive),
+      shareMint: (0, import_common8.toWeb3Pk)(args.shareMint),
+      shareTokenProgram: (0, import_common8.toWeb3Pk)(args.shareTokenProgram),
+      recipientShareAta: (0, import_common8.toWeb3Pk)(args.recipientShareAta)
+    }).instruction().then(import_common8.toKitInstruction);
+  }
+};
+var DistributeIncentiveV3Builder = class extends DistributeIncentiveBuilder {
+  async getIx(args) {
+    return this.program.methods.distributeIncentiveV3().accountsStrict({
+      cranker: (0, import_common8.toWeb3Pk)(args.cranker),
+      vault: (0, import_common8.toWeb3Pk)(args.vault),
+      incentive: (0, import_common8.toWeb3Pk)(args.incentive),
+      shareMint: (0, import_common8.toWeb3Pk)(args.shareMint),
+      shareTokenProgram: (0, import_common8.toWeb3Pk)(args.shareTokenProgram)
+    }).remainingAccounts([
+      ...args.recipientShareAtas.map((ata) => ({
+        pubkey: (0, import_common8.toWeb3Pk)(ata),
+        isWritable: true,
+        isSigner: false
+      })),
+      ...(args.recipientSigners ?? args.recipients).map((wallet) => ({
+        pubkey: (0, import_common8.toWeb3Pk)(wallet),
+        isWritable: false,
+        isSigner: true
+      }))
+    ]).instruction().then(import_common8.toKitInstruction);
+  }
+  async deriveIxArgs(args) {
+    const [vault, incentive] = await Promise.all([
+      this.account.fetchVault(args.vault, { fresh: true }),
+      this.account.fetchIncentiveV3(args.incentive)
+    ]);
+    const shareMint = (0, import_common8.fromWeb3Pk)(vault.mint);
+    const shareTokenProgram = tokenProgramAddressFromIdlEnum(
+      vault.mintTokenProgram
+    );
+    const recipients = getIncentiveV3Recipients(incentive);
+    return {
+      ...args,
+      shareMint,
+      shareTokenProgram,
+      recipients: recipients.map(({ wallet }) => wallet),
+      recipientSigners: recipients.filter((entry) => entry.outstandingShares > 0n).map(({ wallet }) => wallet),
+      recipientShareAtas: getIncentiveV3RecipientShareAtas(
+        incentive,
+        shareMint,
+        shareTokenProgram
+      )
+    };
+  }
+};
+
+// src/client/builders/cancelJuniorTrancheWithdraw.ts
+var import_spl_token4 = require("@solana/spl-token");
+var import_web37 = require("@solana/web3.js");
+var import_common9 = __toESM(require_dist());
+var CancelJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
+  async getIx(args) {
+    return this.program.methods.cancelJuniorTrancheWithdraw().accountsPartial({
+      user: (0, import_common9.toWeb3Pk)(args.user),
+      payer: (0, import_common9.toWeb3Pk)(args.payer),
+      vault: (0, import_common9.toWeb3Pk)(args.vault),
+      withdrawalQueue: (0, import_common9.toWeb3Pk)(args.withdrawalQueue),
+      inputMint: (0, import_common9.toWeb3Pk)(args.inputMint),
+      userInputAta: (0, import_common9.toWeb3Pk)(args.userInputAta),
+      queueInputAta: (0, import_common9.toWeb3Pk)(args.queueInputAta),
+      shareTokenProgram: (0, import_common9.toWeb3Pk)(args.shareTokenProgram),
+      associatedTokenProgram: import_spl_token4.ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: import_web37.SystemProgram.programId
+    }).instruction().then(import_common9.toKitInstruction);
+  }
   async deriveIxArgs(txArgs) {
     const payer = txArgs.payer ?? txArgs.user;
     const [[withdrawalQueue], juniorShare] = await Promise.all([
@@ -14568,8 +14956,8 @@ var CancelJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
       withdrawalQueue: queuePda,
       inputMint: juniorShareMint,
       shareTokenProgram,
-      userInputAta: txArgs.userInputAta ?? (0, import_common6.getAtaAddress)(juniorShareMint, txArgs.user, shareTokenProgram),
-      queueInputAta: (0, import_common6.getAtaAddress)(
+      userInputAta: txArgs.userInputAta ?? (0, import_common9.getAtaAddress)(juniorShareMint, txArgs.user, shareTokenProgram),
+      queueInputAta: (0, import_common9.getAtaAddress)(
         juniorShareMint,
         queuePda,
         shareTokenProgram,
@@ -14587,19 +14975,19 @@ var CancelJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/createAssetHolding.ts
-var import_common7 = __toESM(require_dist());
+var import_common10 = __toESM(require_dist());
 var CreateAssetHoldingBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.createAssetHolding({
       priceOracleType: args.args.priceOracleType,
-      priceOracleAccount: (0, import_common7.toWeb3Pk)(args.args.priceOracleAccount)
+      priceOracleAccount: (0, import_common10.toWeb3Pk)(args.args.priceOracleAccount)
     }).accountsPartial({
-      hwManager: (0, import_common7.toWeb3Pk)(args.hwManager),
-      vault: (0, import_common7.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common7.toWeb3Pk)(args.vaultOracle),
-      mint: (0, import_common7.toWeb3Pk)(args.mint),
-      tokenProgram: (0, import_common7.toWeb3Pk)(args.tokenProgram)
-    }).instruction().then(import_common7.toKitInstruction);
+      hwManager: (0, import_common10.toWeb3Pk)(args.hwManager),
+      vault: (0, import_common10.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common10.toWeb3Pk)(args.vaultOracle),
+      mint: (0, import_common10.toWeb3Pk)(args.mint),
+      tokenProgram: (0, import_common10.toWeb3Pk)(args.tokenProgram)
+    }).instruction().then(import_common10.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(txArgs.vault);
@@ -14625,15 +15013,15 @@ var CreateAssetHoldingBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/removeAssetHolding.ts
-var import_common8 = __toESM(require_dist());
+var import_common11 = __toESM(require_dist());
 var RemoveAssetHoldingBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.removeAssetHolding().accountsPartial({
-      hwManager: (0, import_common8.toWeb3Pk)(args.hwManager),
-      vault: (0, import_common8.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common8.toWeb3Pk)(args.vaultOracle),
-      mint: (0, import_common8.toWeb3Pk)(args.mint)
-    }).instruction().then(import_common8.toKitInstruction);
+      hwManager: (0, import_common11.toWeb3Pk)(args.hwManager),
+      vault: (0, import_common11.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common11.toWeb3Pk)(args.vaultOracle),
+      mint: (0, import_common11.toWeb3Pk)(args.mint)
+    }).instruction().then(import_common11.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(txArgs.vault);
@@ -14654,16 +15042,16 @@ var RemoveAssetHoldingBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/updateConsensusSigners.ts
-var import_common9 = __toESM(require_dist());
+var import_common12 = __toESM(require_dist());
 var UpdateConsensusSignersBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.updateConsensusSigners({
-      signers: args.args.signers.map(import_common9.toWeb3Pk)
+      signers: args.args.signers.map(import_common12.toWeb3Pk)
     }).accountsPartial({
-      curator: (0, import_common9.toWeb3Pk)(args.curator),
-      vault: (0, import_common9.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common9.toWeb3Pk)(args.vaultOracle)
-    }).instruction().then(import_common9.toKitInstruction);
+      curator: (0, import_common12.toWeb3Pk)(args.curator),
+      vault: (0, import_common12.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common12.toWeb3Pk)(args.vaultOracle)
+    }).instruction().then(import_common12.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(txArgs.vault);
@@ -14684,9 +15072,9 @@ var UpdateConsensusSignersBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/createTrancheState.ts
-var import_core2 = require("@anchor-lang/core");
-var import_web36 = require("@solana/web3.js");
-var import_common10 = __toESM(require_dist());
+var import_core3 = require("@anchor-lang/core");
+var import_web38 = require("@solana/web3.js");
+var import_common13 = __toESM(require_dist());
 var CreateTrancheStateBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.vaultCreateTrancheState({
@@ -14698,18 +15086,18 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
       juniorDepositCap: args.juniorDepositCap,
       forMigration: args.forMigration
     }).accountsPartial({
-      curator: (0, import_common10.toWeb3Pk)(args.curator),
-      vault: (0, import_common10.toWeb3Pk)(args.vault),
-      vaultTrancheState: (0, import_common10.toWeb3Pk)(args.vaultTrancheState),
-      juniorShareMint: (0, import_common10.toWeb3Pk)(args.juniorShareMint),
-      seniorShareMint: (0, import_common10.toWeb3Pk)(args.seniorShareMint),
+      curator: (0, import_common13.toWeb3Pk)(args.curator),
+      vault: (0, import_common13.toWeb3Pk)(args.vault),
+      vaultTrancheState: (0, import_common13.toWeb3Pk)(args.vaultTrancheState),
+      juniorShareMint: (0, import_common13.toWeb3Pk)(args.juniorShareMint),
+      seniorShareMint: (0, import_common13.toWeb3Pk)(args.seniorShareMint),
       // Optional on-chain: required only on the organic path, where the
       // program enforces a fresh NAV before enabling tranching. Left null on
       // the migration path so Anchor resolves it to the program ID.
-      vaultOracle: args.vaultOracle ? (0, import_common10.toWeb3Pk)(args.vaultOracle) : null,
-      tokenProgram: (0, import_common10.toWeb3Pk)(args.tokenProgram),
-      systemProgram: import_web36.SystemProgram.programId
-    }).instruction().then(import_common10.toKitInstruction);
+      vaultOracle: args.vaultOracle ? (0, import_common13.toWeb3Pk)(args.vaultOracle) : null,
+      tokenProgram: (0, import_common13.toWeb3Pk)(args.tokenProgram),
+      systemProgram: import_web38.SystemProgram.programId
+    }).instruction().then(import_common13.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultTrancheState] = await this.pda.deriveVaultTrancheStatePda(
@@ -14738,10 +15126,10 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
       juniorFloorApyBps: txArgs.juniorFloorApyBps ?? 0,
       earlyUnstakeFeeBps: txArgs.earlyUnstakeFeeBps ?? DEFAULT_JUNIOR_EARLY_UNSTAKE_FEE_BPS,
       standardUnstakeFeeBps: txArgs.standardUnstakeFeeBps ?? DEFAULT_JUNIOR_STANDARD_UNSTAKE_FEE_BPS,
-      targetLockupDurationSecs: new import_core2.BN(
+      targetLockupDurationSecs: new import_core3.BN(
         (txArgs.targetLockupDurationSecs ?? DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS).toString()
       ),
-      juniorDepositCap: new import_core2.BN((txArgs.juniorDepositCap ?? 0n).toString()),
+      juniorDepositCap: new import_core3.BN((txArgs.juniorDepositCap ?? 0n).toString()),
       forMigration,
       tokenProgram: txArgs.tokenProgram ?? TOKEN_PROGRAM_ID
     };
@@ -14756,13 +15144,13 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/activateCircuitBreaker.ts
-var import_common11 = __toESM(require_dist());
+var import_common14 = __toESM(require_dist());
 var ActivateCircuitBreakerBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.activateCircuitBreaker().accountsPartial({
-      cbTrigger: (0, import_common11.toWeb3Pk)(args.cbTrigger),
-      vault: (0, import_common11.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common11.toKitInstruction);
+      cbTrigger: (0, import_common14.toWeb3Pk)(args.cbTrigger),
+      vault: (0, import_common14.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common14.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return txArgs;
@@ -14775,34 +15163,34 @@ var ActivateCircuitBreakerBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/createVault.ts
-var import_core4 = require("@anchor-lang/core");
+var import_core5 = require("@anchor-lang/core");
 var import_token = require("@solana-program/token");
 var import_spl_token5 = require("@solana/spl-token");
-var import_web37 = require("@solana/web3.js");
-var import_common13 = __toESM(require_dist());
+var import_web39 = require("@solana/web3.js");
+var import_common16 = __toESM(require_dist());
 
 // src/client/builders/anchorArgs.ts
-var import_core3 = require("@anchor-lang/core");
-var import_common12 = __toESM(require_dist());
+var import_core4 = require("@anchor-lang/core");
+var import_common15 = __toESM(require_dist());
 function toAnchorCreateVaultParams(params) {
   return {
     ...params,
-    hwManager: (0, import_common12.toWeb3Pk)(params.hwManager),
-    cbTrigger: (0, import_common12.toWeb3Pk)(params.cbTrigger),
-    feeCollector: (0, import_common12.toWeb3Pk)(params.feeCollector),
-    baseAssetMint: (0, import_common12.toWeb3Pk)(params.baseAssetMint),
-    basePriceOracleAccount: (0, import_common12.toWeb3Pk)(params.basePriceOracleAccount),
-    consensusSigners: params.consensusSigners.map(import_common12.toWeb3Pk)
+    hwManager: (0, import_common15.toWeb3Pk)(params.hwManager),
+    cbTrigger: (0, import_common15.toWeb3Pk)(params.cbTrigger),
+    feeCollector: (0, import_common15.toWeb3Pk)(params.feeCollector),
+    baseAssetMint: (0, import_common15.toWeb3Pk)(params.baseAssetMint),
+    basePriceOracleAccount: (0, import_common15.toWeb3Pk)(params.basePriceOracleAccount),
+    consensusSigners: params.consensusSigners.map(import_common15.toWeb3Pk)
   };
 }
 function toAnchorSetVaultConfigArgs(args) {
   return {
-    manager: args.manager ? (0, import_common12.toWeb3Pk)(args.manager) : null,
-    hwManager: args.hwManager ? (0, import_common12.toWeb3Pk)(args.hwManager) : null,
-    cbTrigger: args.cbTrigger ? (0, import_common12.toWeb3Pk)(args.cbTrigger) : null,
-    fulfiller: args.fulfiller ? (0, import_common12.toWeb3Pk)(args.fulfiller) : null,
-    feeCollector: args.feeCollector ? (0, import_common12.toWeb3Pk)(args.feeCollector) : null,
-    newCurator: args.newCurator ? (0, import_common12.toWeb3Pk)(args.newCurator) : null,
+    manager: args.manager ? (0, import_common15.toWeb3Pk)(args.manager) : null,
+    hwManager: args.hwManager ? (0, import_common15.toWeb3Pk)(args.hwManager) : null,
+    cbTrigger: args.cbTrigger ? (0, import_common15.toWeb3Pk)(args.cbTrigger) : null,
+    fulfiller: args.fulfiller ? (0, import_common15.toWeb3Pk)(args.fulfiller) : null,
+    feeCollector: args.feeCollector ? (0, import_common15.toWeb3Pk)(args.feeCollector) : null,
+    newCurator: args.newCurator ? (0, import_common15.toWeb3Pk)(args.newCurator) : null,
     mintFeeBps: args.mintFeeBps,
     burnFeeBps: args.burnFeeBps,
     performanceFeeBps: args.performanceFeeBps,
@@ -14819,9 +15207,9 @@ function toAnchorSetVaultConfigArgs(args) {
 function toAnchorConsensusUpdates(updates) {
   return updates.map((update) => ({
     holdingIndex: update.holdingIndex,
-    mint: update.mint ? (0, import_common12.toWeb3Pk)(update.mint) : null,
-    price: new import_core3.BN(update.price.toString()),
-    externalAmount: new import_core3.BN(update.externalAmount.toString())
+    mint: update.mint ? (0, import_common15.toWeb3Pk)(update.mint) : null,
+    price: new import_core4.BN(update.price.toString()),
+    externalAmount: new import_core4.BN(update.externalAmount.toString())
   }));
 }
 
@@ -14829,16 +15217,16 @@ function toAnchorConsensusUpdates(updates) {
 var CreateVaultBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.createVault(toAnchorCreateVaultParams(args.params)).accountsPartial({
-      curator: (0, import_common13.toWeb3Pk)(args.curator),
-      vault: (0, import_common13.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common13.toWeb3Pk)(args.vaultOracle),
-      feeVault: (0, import_common13.toWeb3Pk)(args.feeVault),
-      shareMint: (0, import_common13.toWeb3Pk)(args.shareMint),
-      assetMint: (0, import_common13.toWeb3Pk)(args.assetMint),
-      assetTokenProgram: (0, import_common13.toWeb3Pk)(args.assetTokenProgram),
-      tokenProgram: (0, import_common13.toWeb3Pk)(args.shareTokenProgram ?? TOKEN_PROGRAM_ID),
-      systemProgram: import_web37.SystemProgram.programId
-    }).instruction().then(import_common13.toKitInstruction);
+      curator: (0, import_common16.toWeb3Pk)(args.curator),
+      vault: (0, import_common16.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common16.toWeb3Pk)(args.vaultOracle),
+      feeVault: (0, import_common16.toWeb3Pk)(args.feeVault),
+      shareMint: (0, import_common16.toWeb3Pk)(args.shareMint),
+      assetMint: (0, import_common16.toWeb3Pk)(args.assetMint),
+      assetTokenProgram: (0, import_common16.toWeb3Pk)(args.assetTokenProgram),
+      tokenProgram: (0, import_common16.toWeb3Pk)(args.shareTokenProgram ?? TOKEN_PROGRAM_ID),
+      systemProgram: import_web39.SystemProgram.programId
+    }).instruction().then(import_common16.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const vaultId = txArgs.vaultId ?? DEFAULT_VAULT_ID;
@@ -14867,11 +15255,11 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
         performanceFeeBps: txArgs.performanceFeeBps ?? 0,
         fixedApyBps: txArgs.fixedApyBps ?? 0,
         maxApyBps: txArgs.maxApyBps ?? DEFAULT_MAX_ACCEPTABLE_APY_BPS,
-        tvlLimit: new import_core4.BN((txArgs.tvlLimit ?? 0n).toString()),
+        tvlLimit: new import_core5.BN((txArgs.tvlLimit ?? 0n).toString()),
         lossesEnabled: txArgs.lossesEnabled ?? false,
         initialMintSharePrice: null,
         basePriceOracleType: txArgs.basePriceOracleType ?? 1,
-        basePrice: new import_core4.BN(
+        basePrice: new import_core5.BN(
           (txArgs.basePrice ?? 10n ** BigInt(accountingDecimals)).toString()
         ),
         basePriceOracleAccount: txArgs.basePriceOracleAccount ?? DEFAULT_PRICE_ORACLE_ACCOUNT,
@@ -14883,16 +15271,16 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
   async getTx(txArgs) {
     const args = await this.deriveIxArgs(txArgs);
     const createIx = await this.getIx(args);
-    const payer = (0, import_common13.toWeb3Pk)(args.curator);
-    const assetMint = (0, import_common13.toWeb3Pk)(args.assetMint);
-    const assetTokenProgram = (0, import_common13.toWeb3Pk)(args.assetTokenProgram);
-    const vaultAssetAta = (0, import_common13.getAtaAddress)(
+    const payer = (0, import_common16.toWeb3Pk)(args.curator);
+    const assetMint = (0, import_common16.toWeb3Pk)(args.assetMint);
+    const assetTokenProgram = (0, import_common16.toWeb3Pk)(args.assetTokenProgram);
+    const vaultAssetAta = (0, import_common16.getAtaAddress)(
       args.assetMint,
       args.vault,
       args.assetTokenProgram,
       true
     );
-    const feeVaultAta = (0, import_common13.getAtaAddress)(
+    const feeVaultAta = (0, import_common16.getAtaAddress)(
       args.assetMint,
       args.feeVault,
       args.assetTokenProgram,
@@ -14900,16 +15288,16 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
     );
     const createVaultAssetAta = (0, import_spl_token5.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common13.toWeb3Pk)(vaultAssetAta),
-      (0, import_common13.toWeb3Pk)(args.vault),
+      (0, import_common16.toWeb3Pk)(vaultAssetAta),
+      (0, import_common16.toWeb3Pk)(args.vault),
       assetMint,
       assetTokenProgram,
       import_spl_token5.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createFeeVaultAta = (0, import_spl_token5.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common13.toWeb3Pk)(feeVaultAta),
-      (0, import_common13.toWeb3Pk)(args.feeVault),
+      (0, import_common16.toWeb3Pk)(feeVaultAta),
+      (0, import_common16.toWeb3Pk)(args.feeVault),
       assetMint,
       assetTokenProgram,
       import_spl_token5.ASSOCIATED_TOKEN_PROGRAM_ID
@@ -14917,8 +15305,8 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
     return {
       instructions: [
         createIx,
-        (0, import_common13.toKitInstruction)(createVaultAssetAta),
-        (0, import_common13.toKitInstruction)(createFeeVaultAta)
+        (0, import_common16.toKitInstruction)(createVaultAssetAta),
+        (0, import_common16.toKitInstruction)(createFeeVaultAta)
       ],
       postSuccessCacheInvalidations: [
         { vaultPda: args.vault, vaultOraclePda: args.vaultOracle }
@@ -14928,16 +15316,16 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/initializeVaultRoles.ts
-var import_common14 = __toESM(require_dist());
+var import_common17 = __toESM(require_dist());
 var InitializeVaultRolesBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.initializeVaultRoles({
-      manager: (0, import_common14.toWeb3Pk)(args.args.manager),
-      fulfiller: (0, import_common14.toWeb3Pk)(args.args.fulfiller)
+      manager: (0, import_common17.toWeb3Pk)(args.args.manager),
+      fulfiller: (0, import_common17.toWeb3Pk)(args.args.fulfiller)
     }).accountsPartial({
-      curator: (0, import_common14.toWeb3Pk)(args.curator),
-      vault: (0, import_common14.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common14.toKitInstruction);
+      curator: (0, import_common17.toWeb3Pk)(args.curator),
+      vault: (0, import_common17.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common17.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return {
@@ -14957,13 +15345,13 @@ var InitializeVaultRolesBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/disableCircuitBreaker.ts
-var import_common15 = __toESM(require_dist());
+var import_common18 = __toESM(require_dist());
 var DisableCircuitBreakerBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.disableCircuitBreaker().accountsPartial({
-      curator: (0, import_common15.toWeb3Pk)(args.curator),
-      vault: (0, import_common15.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common15.toKitInstruction);
+      curator: (0, import_common18.toWeb3Pk)(args.curator),
+      vault: (0, import_common18.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common18.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return txArgs;
@@ -14976,15 +15364,15 @@ var DisableCircuitBreakerBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/setVaultConfig.ts
-var import_core5 = require("@anchor-lang/core");
-var import_common16 = __toESM(require_dist());
+var import_core6 = require("@anchor-lang/core");
+var import_common19 = __toESM(require_dist());
 var SetVaultConfigBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.setVaultConfig(toAnchorSetVaultConfigArgs(args.args)).accountsPartial({
-      curator: (0, import_common16.toWeb3Pk)(args.curator),
-      vault: (0, import_common16.toWeb3Pk)(args.vault),
-      vaultOracle: args.vaultOracle ? (0, import_common16.toWeb3Pk)(args.vaultOracle) : null
-    }).instruction().then(import_common16.toKitInstruction);
+      curator: (0, import_common19.toWeb3Pk)(args.curator),
+      vault: (0, import_common19.toWeb3Pk)(args.vault),
+      vaultOracle: args.vaultOracle ? (0, import_common19.toWeb3Pk)(args.vaultOracle) : null
+    }).instruction().then(import_common19.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [derivedVaultOracle] = await this.pda.deriveVaultOraclePda(
@@ -15006,28 +15394,28 @@ var SetVaultConfigBuilder = class extends VaultBuilderBase {
         performanceFeeBps: txArgs.performanceFeeBps ?? null,
         fixedApyBps: txArgs.fixedApyBps ?? null,
         maxApyBps: txArgs.maxApyBps ?? null,
-        tvlLimit: txArgs.tvlLimit !== void 0 ? new import_core5.BN(txArgs.tvlLimit.toString()) : null,
+        tvlLimit: txArgs.tvlLimit !== void 0 ? new import_core6.BN(txArgs.tvlLimit.toString()) : null,
         lossesEnabled: txArgs.lossesEnabled ?? null,
-        priceStalenessThresholdSecs: txArgs.priceStalenessThresholdSecs !== void 0 ? new import_core5.BN(txArgs.priceStalenessThresholdSecs.toString()) : null,
+        priceStalenessThresholdSecs: txArgs.priceStalenessThresholdSecs !== void 0 ? new import_core6.BN(txArgs.priceStalenessThresholdSecs.toString()) : null,
         userBurnLimit: txArgs.userBurnLimit !== void 0 ? {
-          windowLimit: new import_core5.BN(
+          windowLimit: new import_core6.BN(
             txArgs.userBurnLimit.windowLimit.toString()
           ),
-          windowDurationSeconds: new import_core5.BN(
+          windowDurationSeconds: new import_core6.BN(
             txArgs.userBurnLimit.windowDurationSeconds.toString()
           )
         } : null,
         managerPullLimit: txArgs.managerPullLimit !== void 0 ? {
-          windowLimit: new import_core5.BN(
+          windowLimit: new import_core6.BN(
             txArgs.managerPullLimit.windowLimit.toString()
           ),
-          windowDurationSeconds: new import_core5.BN(
+          windowDurationSeconds: new import_core6.BN(
             txArgs.managerPullLimit.windowDurationSeconds.toString()
           )
         } : null,
         rebalanceLimit: txArgs.rebalanceLimit !== void 0 ? {
           windowLimitBps: txArgs.rebalanceLimit.windowLimitBps,
-          windowDurationSeconds: new import_core5.BN(
+          windowDurationSeconds: new import_core6.BN(
             txArgs.rebalanceLimit.windowDurationSeconds.toString()
           )
         } : null
@@ -15042,14 +15430,14 @@ var SetVaultConfigBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/setProtocolFee.ts
-var import_common17 = __toESM(require_dist());
+var import_common20 = __toESM(require_dist());
 var SetProtocolFeeBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.setProtocolFee({ protocolFeeBps: args.args.protocolFeeBps }).accountsPartial({
-      protocolAuthority: (0, import_common17.toWeb3Pk)(args.protocolAuthority),
-      vault: (0, import_common17.toWeb3Pk)(args.vault),
-      vaultOracle: args.vaultOracle ? (0, import_common17.toWeb3Pk)(args.vaultOracle) : null
-    }).instruction().then(import_common17.toKitInstruction);
+      protocolAuthority: (0, import_common20.toWeb3Pk)(args.protocolAuthority),
+      vault: (0, import_common20.toWeb3Pk)(args.vault),
+      vaultOracle: args.vaultOracle ? (0, import_common20.toWeb3Pk)(args.vaultOracle) : null
+    }).instruction().then(import_common20.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [derivedVaultOracle] = await this.pda.deriveVaultOraclePda(
@@ -15075,11 +15463,11 @@ var SetProtocolFeeBuilder = class extends VaultBuilderBase {
 // src/client/builders/crankNav.ts
 var import_spl_token6 = require("@solana/spl-token");
 var import_kit6 = require("@solana/kit");
-var import_web38 = require("@solana/web3.js");
-var import_common19 = __toESM(require_dist());
+var import_web310 = require("@solana/web3.js");
+var import_common22 = __toESM(require_dist());
 
 // src/client/builders/feeCollector.ts
-var import_common18 = __toESM(require_dist());
+var import_common21 = __toESM(require_dist());
 function resolveProtocolFeeRecipient(override) {
   return override ?? PROTOCOL_FEE_RECIPIENT;
 }
@@ -15088,14 +15476,14 @@ async function resolveVaultFeeCollector(account, vault, override) {
     return override;
   }
   const vaultState = await account.fetchVault(vault);
-  return (0, import_common18.fromWeb3Pk)(vaultState.roles.feeCollector);
+  return (0, import_common21.fromWeb3Pk)(vaultState.roles.feeCollector);
 }
 function baseAssetMintFromVault(vaultState) {
   const baseHolding = vaultState.holdings.find((holding) => holding.isBase);
   if (!baseHolding) {
     throw new Error("Vault has no base asset holding");
   }
-  return (0, import_common18.fromWeb3Pk)(baseHolding.mint);
+  return (0, import_common21.fromWeb3Pk)(baseHolding.mint);
 }
 async function resolveVaultBaseAssetMint(account, vault, override) {
   if (override) {
@@ -15110,7 +15498,7 @@ async function resolveFeeAssetTokenProgram(account, vault, feeAssetMint, overrid
   }
   const vaultState = await account.fetchVault(vault);
   const holding = vaultState.holdings.find(
-    (entry) => (0, import_common18.fromWeb3Pk)(entry.mint) === feeAssetMint
+    (entry) => (0, import_common21.fromWeb3Pk)(entry.mint) === feeAssetMint
   );
   if (!holding) {
     return TOKEN_PROGRAM_ID;
@@ -15122,21 +15510,21 @@ async function resolveFeeAssetTokenProgram(account, vault, feeAssetMint, overrid
 var CrankNavBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.crankNav().accountsPartial({
-      cranker: (0, import_common19.toWeb3Pk)(args.cranker),
-      vault: (0, import_common19.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common19.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: args.vaultTrancheState ? (0, import_common19.toWeb3Pk)(args.vaultTrancheState) : null,
-      shareMint: (0, import_common19.toWeb3Pk)(args.shareMint),
-      juniorTrancheShareMint: args.juniorTrancheShareMint ? (0, import_common19.toWeb3Pk)(args.juniorTrancheShareMint) : null,
-      seniorTrancheShareMint: args.seniorTrancheShareMint ? (0, import_common19.toWeb3Pk)(args.seniorTrancheShareMint) : null,
-      feeAssetMint: (0, import_common19.toWeb3Pk)(args.feeAssetMint),
-      vaultFeeAssetAta: (0, import_common19.toWeb3Pk)(args.vaultFeeAssetAta),
-      feeVault: (0, import_common19.toWeb3Pk)(args.feeVault),
-      feeVaultAta: (0, import_common19.toWeb3Pk)(args.feeVaultAta),
-      feeAssetTokenProgram: (0, import_common19.toWeb3Pk)(args.feeAssetTokenProgram),
+      cranker: (0, import_common22.toWeb3Pk)(args.cranker),
+      vault: (0, import_common22.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common22.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common22.toWeb3Pk)(args.vaultTrancheState) : null,
+      shareMint: (0, import_common22.toWeb3Pk)(args.shareMint),
+      juniorTrancheShareMint: args.juniorTrancheShareMint ? (0, import_common22.toWeb3Pk)(args.juniorTrancheShareMint) : null,
+      seniorTrancheShareMint: args.seniorTrancheShareMint ? (0, import_common22.toWeb3Pk)(args.seniorTrancheShareMint) : null,
+      feeAssetMint: (0, import_common22.toWeb3Pk)(args.feeAssetMint),
+      vaultFeeAssetAta: (0, import_common22.toWeb3Pk)(args.vaultFeeAssetAta),
+      feeVault: (0, import_common22.toWeb3Pk)(args.feeVault),
+      feeVaultAta: (0, import_common22.toWeb3Pk)(args.feeVaultAta),
+      feeAssetTokenProgram: (0, import_common22.toWeb3Pk)(args.feeAssetTokenProgram),
       associatedTokenProgram: import_spl_token6.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web38.SystemProgram.programId
-    }).instruction().then(import_common19.toKitInstruction);
+      systemProgram: import_web310.SystemProgram.programId
+    }).instruction().then(import_common22.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(txArgs.vault);
@@ -15186,13 +15574,13 @@ var CrankNavBuilder = class extends VaultBuilderBase {
       seniorTrancheShareMint,
       feeAssetMint,
       feeVault,
-      vaultFeeAssetAta: (0, import_common19.getAtaAddress)(
+      vaultFeeAssetAta: (0, import_common22.getAtaAddress)(
         feeAssetMint,
         txArgs.vault,
         feeAssetTokenProgram,
         true
       ),
-      feeVaultAta: (0, import_common19.getAtaAddress)(
+      feeVaultAta: (0, import_common22.getAtaAddress)(
         feeAssetMint,
         feeVault,
         feeAssetTokenProgram,
@@ -15202,25 +15590,25 @@ var CrankNavBuilder = class extends VaultBuilderBase {
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common19.toWeb3Pk)(args.cranker);
+    const payer = (0, import_common22.toWeb3Pk)(args.cranker);
     return [
       (0, import_spl_token6.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common19.toWeb3Pk)(args.vaultFeeAssetAta),
-        (0, import_common19.toWeb3Pk)(args.vault),
-        (0, import_common19.toWeb3Pk)(args.feeAssetMint),
-        (0, import_common19.toWeb3Pk)(args.feeAssetTokenProgram),
+        (0, import_common22.toWeb3Pk)(args.vaultFeeAssetAta),
+        (0, import_common22.toWeb3Pk)(args.vault),
+        (0, import_common22.toWeb3Pk)(args.feeAssetMint),
+        (0, import_common22.toWeb3Pk)(args.feeAssetTokenProgram),
         import_spl_token6.ASSOCIATED_TOKEN_PROGRAM_ID
       ),
       (0, import_spl_token6.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common19.toWeb3Pk)(args.feeVaultAta),
-        (0, import_common19.toWeb3Pk)(args.feeVault),
-        (0, import_common19.toWeb3Pk)(args.feeAssetMint),
-        (0, import_common19.toWeb3Pk)(args.feeAssetTokenProgram),
+        (0, import_common22.toWeb3Pk)(args.feeVaultAta),
+        (0, import_common22.toWeb3Pk)(args.feeVault),
+        (0, import_common22.toWeb3Pk)(args.feeAssetMint),
+        (0, import_common22.toWeb3Pk)(args.feeAssetTokenProgram),
         import_spl_token6.ASSOCIATED_TOKEN_PROGRAM_ID
       )
-    ].map(import_common19.toKitInstruction);
+    ].map(import_common22.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -15247,28 +15635,28 @@ var CrankNavBuilder = class extends VaultBuilderBase {
 
 // src/client/builders/crankPerformanceFees.ts
 var import_spl_token7 = require("@solana/spl-token");
-var import_web39 = require("@solana/web3.js");
-var import_common20 = __toESM(require_dist());
+var import_web311 = require("@solana/web3.js");
+var import_common23 = __toESM(require_dist());
 var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.crankPerformanceFees().accountsPartial({
-      cranker: (0, import_common20.toWeb3Pk)(args.cranker),
-      vault: (0, import_common20.toWeb3Pk)(args.vault),
-      shareMint: (0, import_common20.toWeb3Pk)(args.shareMint),
-      feeCollector: (0, import_common20.toWeb3Pk)(args.feeCollector),
-      feeCollectorShareAta: (0, import_common20.toWeb3Pk)(args.feeCollectorShareAta),
-      protocolFeeCollector: (0, import_common20.toWeb3Pk)(args.protocolFeeCollector),
-      protocolFeeCollectorShareAta: (0, import_common20.toWeb3Pk)(
+      cranker: (0, import_common23.toWeb3Pk)(args.cranker),
+      vault: (0, import_common23.toWeb3Pk)(args.vault),
+      shareMint: (0, import_common23.toWeb3Pk)(args.shareMint),
+      feeCollector: (0, import_common23.toWeb3Pk)(args.feeCollector),
+      feeCollectorShareAta: (0, import_common23.toWeb3Pk)(args.feeCollectorShareAta),
+      protocolFeeCollector: (0, import_common23.toWeb3Pk)(args.protocolFeeCollector),
+      protocolFeeCollectorShareAta: (0, import_common23.toWeb3Pk)(
         args.protocolFeeCollectorShareAta
       ),
-      shareTokenProgram: (0, import_common20.toWeb3Pk)(args.shareTokenProgram),
+      shareTokenProgram: (0, import_common23.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token7.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web39.SystemProgram.programId
-    }).instruction().then(import_common20.toKitInstruction);
+      systemProgram: import_web311.SystemProgram.programId
+    }).instruction().then(import_common23.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const vaultState = await this.account.fetchVault(txArgs.vault);
-    const shareMint = (0, import_common20.fromWeb3Pk)(vaultState.mint);
+    const shareMint = (0, import_common23.fromWeb3Pk)(vaultState.mint);
     const shareTokenProgram = txArgs.shareTokenProgram ?? tokenProgramAddressFromIdlEnum(vaultState.mintTokenProgram);
     const feeCollector = await resolveVaultFeeCollector(
       this.account,
@@ -15285,7 +15673,7 @@ var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
       feeCollector,
       // The vault fee collector is a role that is routinely a Squads vault
       // (off-curve PDA), so allow an off-curve owner here too.
-      feeCollectorShareAta: (0, import_common20.getAtaAddress)(
+      feeCollectorShareAta: (0, import_common23.getAtaAddress)(
         shareMint,
         feeCollector,
         shareTokenProgram,
@@ -15295,7 +15683,7 @@ var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
       // The protocol fee recipient is a hardcoded protocol-controlled address
       // that may be off-curve (e.g. a PDA / multisig vault), so allow an
       // off-curve owner when deriving its ATA.
-      protocolFeeCollectorShareAta: (0, import_common20.getAtaAddress)(
+      protocolFeeCollectorShareAta: (0, import_common23.getAtaAddress)(
         shareMint,
         protocolFeeCollector,
         shareTokenProgram,
@@ -15321,7 +15709,7 @@ var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/setExternalLiquidity.ts
-var import_common21 = __toESM(require_dist());
+var import_common24 = __toESM(require_dist());
 function toExternalLiquiditySource(source) {
   switch (source) {
     case 0:
@@ -15337,11 +15725,11 @@ var SetExternalLiquidityBuilder = class extends VaultBuilderBase {
     return this.program.methods.setExternalLiquidity({
       index: args.args.index,
       source: args.args.source,
-      userAccount: (0, import_common21.toWeb3Pk)(args.args.userAccount)
+      userAccount: (0, import_common24.toWeb3Pk)(args.args.userAccount)
     }).accountsPartial({
-      curator: (0, import_common21.toWeb3Pk)(args.curator),
-      vault: (0, import_common21.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common21.toKitInstruction);
+      curator: (0, import_common24.toWeb3Pk)(args.curator),
+      vault: (0, import_common24.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common24.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return {
@@ -15362,16 +15750,16 @@ var SetExternalLiquidityBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/setManagerWithdrawDestination.ts
-var import_common22 = __toESM(require_dist());
+var import_common25 = __toESM(require_dist());
 var SetManagerWithdrawDestinationBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.setManagerWithdrawDestination({
       slot: args.args.slot,
-      address: (0, import_common22.toWeb3Pk)(args.args.address)
+      address: (0, import_common25.toWeb3Pk)(args.args.address)
     }).accountsPartial({
-      curator: (0, import_common22.toWeb3Pk)(args.curator),
-      vault: (0, import_common22.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common22.toKitInstruction);
+      curator: (0, import_common25.toWeb3Pk)(args.curator),
+      vault: (0, import_common25.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common25.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return {
@@ -15391,17 +15779,17 @@ var SetManagerWithdrawDestinationBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/setAssetPriceOracle.ts
-var import_common23 = __toESM(require_dist());
+var import_common26 = __toESM(require_dist());
 var SetAssetPriceOracleBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.setAssetPriceOracle({
-      mint: (0, import_common23.toWeb3Pk)(args.args.mint),
+      mint: (0, import_common26.toWeb3Pk)(args.args.mint),
       priceOracleType: args.args.priceOracleType,
-      priceOracleAccount: (0, import_common23.toWeb3Pk)(args.args.priceOracleAccount)
+      priceOracleAccount: (0, import_common26.toWeb3Pk)(args.args.priceOracleAccount)
     }).accountsPartial({
-      curator: (0, import_common23.toWeb3Pk)(args.curator),
-      vault: (0, import_common23.toWeb3Pk)(args.vault)
-    }).instruction().then(import_common23.toKitInstruction);
+      curator: (0, import_common26.toWeb3Pk)(args.curator),
+      vault: (0, import_common26.toWeb3Pk)(args.vault)
+    }).instruction().then(import_common26.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return {
@@ -15422,19 +15810,19 @@ var SetAssetPriceOracleBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/updateAssetPrice.ts
-var import_core6 = require("@anchor-lang/core");
-var import_common24 = __toESM(require_dist());
+var import_core7 = require("@anchor-lang/core");
+var import_common27 = __toESM(require_dist());
 var DEFAULT_PRICE_MAX_AGE_SECS = 90n;
 var UpdateAssetPriceBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.updateAssetPrice({
-      mint: (0, import_common24.toWeb3Pk)(args.args.mint),
+      mint: (0, import_common27.toWeb3Pk)(args.args.mint),
       maxAgeSecs: args.args.maxAgeSecs
     }).accountsPartial({
-      updater: (0, import_common24.toWeb3Pk)(args.updater),
-      vault: (0, import_common24.toWeb3Pk)(args.vault),
-      oracleAccount: (0, import_common24.toWeb3Pk)(args.oracleAccount)
-    }).instruction().then(import_common24.toKitInstruction);
+      updater: (0, import_common27.toWeb3Pk)(args.updater),
+      vault: (0, import_common27.toWeb3Pk)(args.vault),
+      oracleAccount: (0, import_common27.toWeb3Pk)(args.oracleAccount)
+    }).instruction().then(import_common27.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     return {
@@ -15443,7 +15831,7 @@ var UpdateAssetPriceBuilder = class extends VaultBuilderBase {
       oracleAccount: txArgs.oracleAccount,
       args: {
         mint: txArgs.mint,
-        maxAgeSecs: new import_core6.BN(
+        maxAgeSecs: new import_core7.BN(
           (txArgs.maxAgeSecs ?? DEFAULT_PRICE_MAX_AGE_SECS).toString()
         )
       }
@@ -15466,18 +15854,18 @@ var UpdateAssetPriceBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/updateConsensusOracle.ts
-var import_common25 = __toESM(require_dist());
+var import_common28 = __toESM(require_dist());
 var UpdateConsensusOracleBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.updateConsensusOracle({
       updates: toAnchorConsensusUpdates(args.updates)
     }).accountsPartial({
-      signer: (0, import_common25.toWeb3Pk)(args.signer),
-      vault: (0, import_common25.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common25.toWeb3Pk)(args.vaultOracle),
-      assetMint: args.assetMint ? (0, import_common25.toWeb3Pk)(args.assetMint) : null,
-      assetTokenProgram: args.assetTokenProgram ? (0, import_common25.toWeb3Pk)(args.assetTokenProgram) : null
-    }).instruction().then(import_common25.toKitInstruction);
+      signer: (0, import_common28.toWeb3Pk)(args.signer),
+      vault: (0, import_common28.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common28.toWeb3Pk)(args.vaultOracle),
+      assetMint: args.assetMint ? (0, import_common28.toWeb3Pk)(args.assetMint) : null,
+      assetTokenProgram: args.assetTokenProgram ? (0, import_common28.toWeb3Pk)(args.assetTokenProgram) : null
+    }).instruction().then(import_common28.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [derivedVaultOracle] = await this.pda.deriveVaultOraclePda(
@@ -15521,25 +15909,25 @@ var UpdateConsensusOracleBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/executeShareSwap.ts
-var import_core7 = require("@anchor-lang/core");
+var import_core8 = require("@anchor-lang/core");
 var import_spl_token8 = require("@solana/spl-token");
-var import_web310 = require("@solana/web3.js");
-var import_common26 = __toESM(require_dist());
+var import_web312 = require("@solana/web3.js");
+var import_common29 = __toESM(require_dist());
 var ExecuteShareSwapBuilder = class extends VaultBuilderBase {
   getIxAccounts(args) {
     return {
-      user: (0, import_common26.toWeb3Pk)(args.user),
-      vault: (0, import_common26.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common26.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: (0, import_common26.toWeb3Pk)(args.vaultTrancheState),
-      shareMint: (0, import_common26.toWeb3Pk)(args.shareMint),
-      trancheShareMint: (0, import_common26.toWeb3Pk)(args.trancheShareMint),
-      userShareAta: (0, import_common26.toWeb3Pk)(args.userShareAta),
-      userTrancheShareAta: (0, import_common26.toWeb3Pk)(args.userTrancheShareAta),
-      shareTokenProgram: (0, import_common26.toWeb3Pk)(args.shareTokenProgram),
-      trancheShareTokenProgram: (0, import_common26.toWeb3Pk)(args.trancheShareTokenProgram),
+      user: (0, import_common29.toWeb3Pk)(args.user),
+      vault: (0, import_common29.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common29.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: (0, import_common29.toWeb3Pk)(args.vaultTrancheState),
+      shareMint: (0, import_common29.toWeb3Pk)(args.shareMint),
+      trancheShareMint: (0, import_common29.toWeb3Pk)(args.trancheShareMint),
+      userShareAta: (0, import_common29.toWeb3Pk)(args.userShareAta),
+      userTrancheShareAta: (0, import_common29.toWeb3Pk)(args.userTrancheShareAta),
+      shareTokenProgram: (0, import_common29.toWeb3Pk)(args.shareTokenProgram),
+      trancheShareTokenProgram: (0, import_common29.toWeb3Pk)(args.trancheShareTokenProgram),
       associatedTokenProgram: import_spl_token8.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web310.SystemProgram.programId
+      systemProgram: import_web312.SystemProgram.programId
     };
   }
   getIxData(args) {
@@ -15550,7 +15938,7 @@ var ExecuteShareSwapBuilder = class extends VaultBuilderBase {
   }
   async getIx(args) {
     const data = this.getIxData(args);
-    return this.program.methods.executeShareSwap(data.kind, data.shareAmount).accountsPartial(this.getIxAccounts(args)).instruction().then(import_common26.toKitInstruction);
+    return this.program.methods.executeShareSwap(data.kind, data.shareAmount).accountsPartial(this.getIxAccounts(args)).instruction().then(import_common29.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [
@@ -15581,11 +15969,11 @@ var ExecuteShareSwapBuilder = class extends VaultBuilderBase {
       shareMint,
       trancheShareMint,
       kind: txArgs.kind,
-      shareAmount: new import_core7.BN(txArgs.shareAmount.toString()),
+      shareAmount: new import_core8.BN(txArgs.shareAmount.toString()),
       shareTokenProgram,
       trancheShareTokenProgram,
-      userShareAta: (0, import_common26.getAtaAddress)(shareMint, txArgs.user, shareTokenProgram),
-      userTrancheShareAta: (0, import_common26.getAtaAddress)(
+      userShareAta: (0, import_common29.getAtaAddress)(shareMint, txArgs.user, shareTokenProgram),
+      userTrancheShareAta: (0, import_common29.getAtaAddress)(
         trancheShareMint,
         txArgs.user,
         trancheShareTokenProgram
@@ -15593,16 +15981,16 @@ var ExecuteShareSwapBuilder = class extends VaultBuilderBase {
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common26.toWeb3Pk)(args.user);
+    const payer = (0, import_common29.toWeb3Pk)(args.user);
     const createUserTrancheShareAta = (0, import_spl_token8.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common26.toWeb3Pk)(args.userTrancheShareAta),
+      (0, import_common29.toWeb3Pk)(args.userTrancheShareAta),
       payer,
-      (0, import_common26.toWeb3Pk)(args.trancheShareMint),
-      (0, import_common26.toWeb3Pk)(args.trancheShareTokenProgram),
+      (0, import_common29.toWeb3Pk)(args.trancheShareMint),
+      (0, import_common29.toWeb3Pk)(args.trancheShareTokenProgram),
       import_spl_token8.ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    return [createUserTrancheShareAta].map(import_common26.toKitInstruction);
+    return [createUserTrancheShareAta].map(import_common29.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -15624,25 +16012,25 @@ var ExecuteShareSwapBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/executeDeposit.ts
-var import_core8 = require("@anchor-lang/core");
+var import_core9 = require("@anchor-lang/core");
 var import_spl_token9 = require("@solana/spl-token");
-var import_common27 = __toESM(require_dist());
+var import_common30 = __toESM(require_dist());
 var ExecuteDepositBuilder = class extends VaultBuilderBase {
   getIxAccounts(args) {
     return {
-      user: (0, import_common27.toWeb3Pk)(args.user),
-      vault: (0, import_common27.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common27.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: args.vaultTrancheState ? (0, import_common27.toWeb3Pk)(args.vaultTrancheState) : null,
-      assetMint: (0, import_common27.toWeb3Pk)(args.assetMint),
-      shareMint: (0, import_common27.toWeb3Pk)(args.shareMint),
-      userAssetAta: (0, import_common27.toWeb3Pk)(args.userAssetAta),
-      vaultAssetAta: (0, import_common27.toWeb3Pk)(args.vaultAssetAta),
-      feeVault: (0, import_common27.toWeb3Pk)(args.feeVault),
-      feeVaultAta: (0, import_common27.toWeb3Pk)(args.feeVaultAta),
-      userShareAta: (0, import_common27.toWeb3Pk)(args.userShareAta),
-      assetTokenProgram: (0, import_common27.toWeb3Pk)(args.assetTokenProgram),
-      shareTokenProgram: (0, import_common27.toWeb3Pk)(args.shareTokenProgram)
+      user: (0, import_common30.toWeb3Pk)(args.user),
+      vault: (0, import_common30.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common30.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common30.toWeb3Pk)(args.vaultTrancheState) : null,
+      assetMint: (0, import_common30.toWeb3Pk)(args.assetMint),
+      shareMint: (0, import_common30.toWeb3Pk)(args.shareMint),
+      userAssetAta: (0, import_common30.toWeb3Pk)(args.userAssetAta),
+      vaultAssetAta: (0, import_common30.toWeb3Pk)(args.vaultAssetAta),
+      feeVault: (0, import_common30.toWeb3Pk)(args.feeVault),
+      feeVaultAta: (0, import_common30.toWeb3Pk)(args.feeVaultAta),
+      userShareAta: (0, import_common30.toWeb3Pk)(args.userShareAta),
+      assetTokenProgram: (0, import_common30.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common30.toWeb3Pk)(args.shareTokenProgram)
     };
   }
   getIxData(args) {
@@ -15659,7 +16047,7 @@ var ExecuteDepositBuilder = class extends VaultBuilderBase {
     ) : this.program.methods.executeDeposit(data.amount);
     return methods.accountsPartial(
       this.getIxAccounts(args)
-    ).instruction().then(import_common27.toKitInstruction);
+    ).instruction().then(import_common30.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -15698,61 +16086,61 @@ var ExecuteDepositBuilder = class extends VaultBuilderBase {
       vaultTrancheState,
       assetMint: txArgs.assetMint,
       shareMint: txArgs.shareMint,
-      amount: new import_core8.BN(txArgs.amount.toString()),
+      amount: new import_core9.BN(txArgs.amount.toString()),
       addressSeeds: txArgs.addressSeeds,
       assetTokenProgram,
       shareTokenProgram,
-      userAssetAta: txArgs.userAssetAta ?? (0, import_common27.getAtaAddress)(txArgs.assetMint, txArgs.user, assetTokenProgram),
-      vaultAssetAta: (0, import_common27.getAtaAddress)(
+      userAssetAta: txArgs.userAssetAta ?? (0, import_common30.getAtaAddress)(txArgs.assetMint, txArgs.user, assetTokenProgram),
+      vaultAssetAta: (0, import_common30.getAtaAddress)(
         txArgs.assetMint,
         txArgs.vault,
         assetTokenProgram,
         true
       ),
       feeVault,
-      feeVaultAta: (0, import_common27.getAtaAddress)(
+      feeVaultAta: (0, import_common30.getAtaAddress)(
         txArgs.assetMint,
         feeVault,
         assetTokenProgram,
         true
       ),
-      userShareAta: txArgs.userShareAta ?? (0, import_common27.getAtaAddress)(txArgs.shareMint, txArgs.user, shareTokenProgram)
+      userShareAta: txArgs.userShareAta ?? (0, import_common30.getAtaAddress)(txArgs.shareMint, txArgs.user, shareTokenProgram)
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common27.toWeb3Pk)(args.user);
+    const payer = (0, import_common30.toWeb3Pk)(args.user);
     const createVaultAssetAta = (0, import_spl_token9.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common27.toWeb3Pk)(args.vaultAssetAta),
-      (0, import_common27.toWeb3Pk)(args.vault),
-      (0, import_common27.toWeb3Pk)(args.assetMint),
-      (0, import_common27.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common30.toWeb3Pk)(args.vaultAssetAta),
+      (0, import_common30.toWeb3Pk)(args.vault),
+      (0, import_common30.toWeb3Pk)(args.assetMint),
+      (0, import_common30.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token9.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createFeeVaultAta = (0, import_spl_token9.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common27.toWeb3Pk)(args.feeVaultAta),
-      (0, import_common27.toWeb3Pk)(args.feeVault),
-      (0, import_common27.toWeb3Pk)(args.assetMint),
-      (0, import_common27.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common30.toWeb3Pk)(args.feeVaultAta),
+      (0, import_common30.toWeb3Pk)(args.feeVault),
+      (0, import_common30.toWeb3Pk)(args.assetMint),
+      (0, import_common30.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token9.ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    const defaultUserShareAta = (0, import_common27.getAtaAddress)(
+    const defaultUserShareAta = (0, import_common30.getAtaAddress)(
       args.shareMint,
       args.user,
       args.shareTokenProgram
     );
-    const createUserShareAta = (0, import_common27.toWeb3Pk)(args.userShareAta).equals(
-      (0, import_common27.toWeb3Pk)(defaultUserShareAta)
+    const createUserShareAta = (0, import_common30.toWeb3Pk)(args.userShareAta).equals(
+      (0, import_common30.toWeb3Pk)(defaultUserShareAta)
     ) ? (0, import_spl_token9.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common27.toWeb3Pk)(args.userShareAta),
+      (0, import_common30.toWeb3Pk)(args.userShareAta),
       payer,
-      (0, import_common27.toWeb3Pk)(args.shareMint),
-      (0, import_common27.toWeb3Pk)(args.shareTokenProgram),
+      (0, import_common30.toWeb3Pk)(args.shareMint),
+      (0, import_common30.toWeb3Pk)(args.shareTokenProgram),
       import_spl_token9.ASSOCIATED_TOKEN_PROGRAM_ID
     ) : null;
-    return [createVaultAssetAta, createFeeVaultAta, createUserShareAta].filter((ix) => ix != null).map(import_common27.toKitInstruction);
+    return [createVaultAssetAta, createFeeVaultAta, createUserShareAta].filter((ix) => ix != null).map(import_common30.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -15772,28 +16160,28 @@ var ExecuteDepositBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/executeTrancheDeposit.ts
-var import_core9 = require("@anchor-lang/core");
+var import_core10 = require("@anchor-lang/core");
 var import_spl_token10 = require("@solana/spl-token");
-var import_web311 = require("@solana/web3.js");
-var import_common28 = __toESM(require_dist());
+var import_web313 = require("@solana/web3.js");
+var import_common31 = __toESM(require_dist());
 var ExecuteTrancheDepositBuilder = class extends VaultBuilderBase {
   getIxAccounts(args) {
     return {
-      user: (0, import_common28.toWeb3Pk)(args.user),
-      vault: (0, import_common28.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common28.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: (0, import_common28.toWeb3Pk)(args.vaultTrancheState),
-      assetMint: (0, import_common28.toWeb3Pk)(args.assetMint),
-      trancheShareMint: (0, import_common28.toWeb3Pk)(args.trancheShareMint),
-      userAssetAta: (0, import_common28.toWeb3Pk)(args.userAssetAta),
-      vaultAssetAta: (0, import_common28.toWeb3Pk)(args.vaultAssetAta),
-      feeVault: (0, import_common28.toWeb3Pk)(args.feeVault),
-      feeVaultAta: (0, import_common28.toWeb3Pk)(args.feeVaultAta),
-      userTrancheShareAta: (0, import_common28.toWeb3Pk)(args.userTrancheShareAta),
-      assetTokenProgram: (0, import_common28.toWeb3Pk)(args.assetTokenProgram),
-      shareTokenProgram: (0, import_common28.toWeb3Pk)(args.shareTokenProgram),
+      user: (0, import_common31.toWeb3Pk)(args.user),
+      vault: (0, import_common31.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common31.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: (0, import_common31.toWeb3Pk)(args.vaultTrancheState),
+      assetMint: (0, import_common31.toWeb3Pk)(args.assetMint),
+      trancheShareMint: (0, import_common31.toWeb3Pk)(args.trancheShareMint),
+      userAssetAta: (0, import_common31.toWeb3Pk)(args.userAssetAta),
+      vaultAssetAta: (0, import_common31.toWeb3Pk)(args.vaultAssetAta),
+      feeVault: (0, import_common31.toWeb3Pk)(args.feeVault),
+      feeVaultAta: (0, import_common31.toWeb3Pk)(args.feeVaultAta),
+      userTrancheShareAta: (0, import_common31.toWeb3Pk)(args.userTrancheShareAta),
+      assetTokenProgram: (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common31.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token10.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web311.SystemProgram.programId
+      systemProgram: import_web313.SystemProgram.programId
     };
   }
   getIxData(args) {
@@ -15812,7 +16200,7 @@ var ExecuteTrancheDepositBuilder = class extends VaultBuilderBase {
     ) : this.program.methods.executeTrancheDeposit(data.kind, data.amount);
     return methods.accountsPartial(
       this.getIxAccounts(args)
-    ).instruction().then(import_common28.toKitInstruction);
+    ).instruction().then(import_common31.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -15841,29 +16229,29 @@ var ExecuteTrancheDepositBuilder = class extends VaultBuilderBase {
       assetMint: txArgs.assetMint,
       trancheShareMint,
       kind: txArgs.kind,
-      amount: new import_core9.BN(txArgs.amount.toString()),
+      amount: new import_core10.BN(txArgs.amount.toString()),
       addressSeeds: txArgs.addressSeeds,
       assetTokenProgram,
       shareTokenProgram,
-      userAssetAta: (0, import_common28.getAtaAddress)(
+      userAssetAta: (0, import_common31.getAtaAddress)(
         txArgs.assetMint,
         txArgs.user,
         assetTokenProgram
       ),
-      vaultAssetAta: (0, import_common28.getAtaAddress)(
+      vaultAssetAta: (0, import_common31.getAtaAddress)(
         txArgs.assetMint,
         txArgs.vault,
         assetTokenProgram,
         true
       ),
       feeVault,
-      feeVaultAta: (0, import_common28.getAtaAddress)(
+      feeVaultAta: (0, import_common31.getAtaAddress)(
         txArgs.assetMint,
         feeVault,
         assetTokenProgram,
         true
       ),
-      userTrancheShareAta: (0, import_common28.getAtaAddress)(
+      userTrancheShareAta: (0, import_common31.getAtaAddress)(
         trancheShareMint,
         txArgs.user,
         shareTokenProgram
@@ -15871,33 +16259,33 @@ var ExecuteTrancheDepositBuilder = class extends VaultBuilderBase {
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common28.toWeb3Pk)(args.user);
+    const payer = (0, import_common31.toWeb3Pk)(args.user);
     const createVaultAssetAta = (0, import_spl_token10.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common28.toWeb3Pk)(args.vaultAssetAta),
-      (0, import_common28.toWeb3Pk)(args.vault),
-      (0, import_common28.toWeb3Pk)(args.assetMint),
-      (0, import_common28.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common31.toWeb3Pk)(args.vaultAssetAta),
+      (0, import_common31.toWeb3Pk)(args.vault),
+      (0, import_common31.toWeb3Pk)(args.assetMint),
+      (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token10.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createUserShareAta = (0, import_spl_token10.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common28.toWeb3Pk)(args.userTrancheShareAta),
+      (0, import_common31.toWeb3Pk)(args.userTrancheShareAta),
       payer,
-      (0, import_common28.toWeb3Pk)(args.trancheShareMint),
-      (0, import_common28.toWeb3Pk)(args.shareTokenProgram),
+      (0, import_common31.toWeb3Pk)(args.trancheShareMint),
+      (0, import_common31.toWeb3Pk)(args.shareTokenProgram),
       import_spl_token10.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createFeeVaultAta = (0, import_spl_token10.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common28.toWeb3Pk)(args.feeVaultAta),
-      (0, import_common28.toWeb3Pk)(args.feeVault),
-      (0, import_common28.toWeb3Pk)(args.assetMint),
-      (0, import_common28.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common31.toWeb3Pk)(args.feeVaultAta),
+      (0, import_common31.toWeb3Pk)(args.feeVault),
+      (0, import_common31.toWeb3Pk)(args.assetMint),
+      (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token10.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     return [createVaultAssetAta, createFeeVaultAta, createUserShareAta].map(
-      import_common28.toKitInstruction
+      import_common31.toKitInstruction
     );
   }
   async buildPlanExtras(args) {
@@ -15920,27 +16308,27 @@ var ExecuteTrancheDepositBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/executeTrancheWithdraw.ts
-var import_core10 = require("@anchor-lang/core");
+var import_core11 = require("@anchor-lang/core");
 var import_spl_token11 = require("@solana/spl-token");
-var import_web313 = require("@solana/web3.js");
-var import_common30 = __toESM(require_dist());
+var import_web315 = require("@solana/web3.js");
+var import_common33 = __toESM(require_dist());
 
 // src/client/builders/externalLiquidity.ts
 var import_kit7 = require("@solana/kit");
-var import_web312 = require("@solana/web3.js");
-var import_common29 = __toESM(require_dist());
+var import_web314 = require("@solana/web3.js");
+var import_common32 = __toESM(require_dist());
 var import_marginfi = __toESM(require_dist2());
 function parseMarginfiSlot(slot) {
   const data = slot?.data;
   if (!data || data.length < 40) return null;
   if (data[0] !== 1) return null;
   const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-  const userAccount = new import_web312.PublicKey(pubkeyBytes).toBase58();
+  const userAccount = new import_web314.PublicKey(pubkeyBytes).toBase58();
   return { userAccount };
 }
 function toWeb3AccountMeta(account) {
   return {
-    pubkey: new import_web312.PublicKey(account.address),
+    pubkey: new import_web314.PublicKey(account.address),
     isWritable: account.role === import_kit7.AccountRole.WRITABLE || account.role === import_kit7.AccountRole.WRITABLE_SIGNER,
     isSigner: account.role === import_kit7.AccountRole.READONLY_SIGNER || account.role === import_kit7.AccountRole.WRITABLE_SIGNER
   };
@@ -15979,7 +16367,7 @@ function resolveExternalWithdraw({
     };
   }
   const marginfiClient = new import_marginfi.CpiClient({ accounts: marginfiAccounts });
-  const withdrawRefs = (0, import_common29.createCpiRefs)([
+  const withdrawRefs = (0, import_common32.createCpiRefs)([
     marginfiClient.withdraw_cpi({
       marginfiAccount: slot0.userAccount,
       authority: vault,
@@ -15999,14 +16387,14 @@ function buildMarginfiWithdrawInteraction(args) {
       `No Marginfi market is configured for asset mint ${args.assetMint}`
     );
   }
-  const vaultAssetAta = (0, import_common29.getAtaAddress)(
+  const vaultAssetAta = (0, import_common32.getAtaAddress)(
     args.assetMint,
     args.vault,
     marginfiAccounts.tokenProgram,
     true
   );
   const marginfiClient = new import_marginfi.CpiClient({ accounts: marginfiAccounts });
-  const withdraw = (0, import_common29.createCpiRefs)([
+  const withdraw = (0, import_common32.createCpiRefs)([
     marginfiClient.withdraw_cpi({
       marginfiAccount: args.marginfiAccount,
       authority: args.vault,
@@ -16030,19 +16418,19 @@ function buildMarginfiWithdrawInteraction(args) {
 var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
   getIxAccounts(args) {
     return {
-      user: (0, import_common30.toWeb3Pk)(args.user),
-      vault: (0, import_common30.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common30.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: (0, import_common30.toWeb3Pk)(args.vaultTrancheState),
-      assetMint: (0, import_common30.toWeb3Pk)(args.assetMint),
-      trancheShareMint: (0, import_common30.toWeb3Pk)(args.trancheShareMint),
-      userAssetAta: (0, import_common30.toWeb3Pk)(args.userAssetAta),
-      vaultAssetAta: (0, import_common30.toWeb3Pk)(args.vaultAssetAta),
-      userTrancheShareAta: (0, import_common30.toWeb3Pk)(args.userTrancheShareAta),
-      assetTokenProgram: (0, import_common30.toWeb3Pk)(args.assetTokenProgram),
-      shareTokenProgram: (0, import_common30.toWeb3Pk)(args.shareTokenProgram),
+      user: (0, import_common33.toWeb3Pk)(args.user),
+      vault: (0, import_common33.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common33.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: (0, import_common33.toWeb3Pk)(args.vaultTrancheState),
+      assetMint: (0, import_common33.toWeb3Pk)(args.assetMint),
+      trancheShareMint: (0, import_common33.toWeb3Pk)(args.trancheShareMint),
+      userAssetAta: (0, import_common33.toWeb3Pk)(args.userAssetAta),
+      vaultAssetAta: (0, import_common33.toWeb3Pk)(args.vaultAssetAta),
+      userTrancheShareAta: (0, import_common33.toWeb3Pk)(args.userTrancheShareAta),
+      assetTokenProgram: (0, import_common33.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common33.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token11.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web313.SystemProgram.programId
+      systemProgram: import_web315.SystemProgram.programId
     };
   }
   getIxData(args) {
@@ -16079,7 +16467,7 @@ var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
     );
     return methods.accountsPartial(
       this.getIxAccounts(args)
-    ).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common30.toKitInstruction);
+    ).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common33.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -16100,7 +16488,7 @@ var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
       txArgs.assetTokenProgram
     );
     const { mint: trancheShareMint, tokenProgram: shareTokenProgram } = trancheShare;
-    const vaultAssetAta = (0, import_common30.getAtaAddress)(
+    const vaultAssetAta = (0, import_common33.getAtaAddress)(
       txArgs.assetMint,
       txArgs.vault,
       assetTokenProgram,
@@ -16125,17 +16513,17 @@ var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
       assetMint: txArgs.assetMint,
       trancheShareMint,
       kind: txArgs.kind,
-      shareAmount: new import_core10.BN(txArgs.shareAmount.toString()),
+      shareAmount: new import_core11.BN(txArgs.shareAmount.toString()),
       addressSeeds: txArgs.addressSeeds,
       assetTokenProgram,
       shareTokenProgram,
-      userAssetAta: (0, import_common30.getAtaAddress)(
+      userAssetAta: (0, import_common33.getAtaAddress)(
         txArgs.assetMint,
         txArgs.user,
         assetTokenProgram
       ),
       vaultAssetAta,
-      userTrancheShareAta: (0, import_common30.getAtaAddress)(
+      userTrancheShareAta: (0, import_common33.getAtaAddress)(
         trancheShareMint,
         txArgs.user,
         shareTokenProgram
@@ -16149,16 +16537,16 @@ var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
     return txArgs.lookupTables;
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common30.toWeb3Pk)(args.user);
+    const payer = (0, import_common33.toWeb3Pk)(args.user);
     const createUserAssetAta = (0, import_spl_token11.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common30.toWeb3Pk)(args.userAssetAta),
+      (0, import_common33.toWeb3Pk)(args.userAssetAta),
       payer,
-      (0, import_common30.toWeb3Pk)(args.assetMint),
-      (0, import_common30.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common33.toWeb3Pk)(args.assetMint),
+      (0, import_common33.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token11.ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    return [createUserAssetAta].map(import_common30.toKitInstruction);
+    return [createUserAssetAta].map(import_common33.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -16170,25 +16558,25 @@ var ExecuteTrancheWithdrawBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/executeWithdraw.ts
-var import_core11 = require("@anchor-lang/core");
+var import_core12 = require("@anchor-lang/core");
 var import_spl_token12 = require("@solana/spl-token");
-var import_common31 = __toESM(require_dist());
+var import_common34 = __toESM(require_dist());
 var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
   getIxAccounts(args) {
     return {
-      user: (0, import_common31.toWeb3Pk)(args.user),
-      vault: (0, import_common31.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common31.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: args.vaultTrancheState ? (0, import_common31.toWeb3Pk)(args.vaultTrancheState) : null,
-      assetMint: (0, import_common31.toWeb3Pk)(args.assetMint),
-      shareMint: (0, import_common31.toWeb3Pk)(args.shareMint),
-      userAssetAta: (0, import_common31.toWeb3Pk)(args.userAssetAta),
-      vaultAssetAta: (0, import_common31.toWeb3Pk)(args.vaultAssetAta),
-      feeVault: (0, import_common31.toWeb3Pk)(args.feeVault),
-      feeVaultAta: (0, import_common31.toWeb3Pk)(args.feeVaultAta),
-      userShareAta: (0, import_common31.toWeb3Pk)(args.userShareAta),
-      assetTokenProgram: (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
-      shareTokenProgram: (0, import_common31.toWeb3Pk)(args.shareTokenProgram)
+      user: (0, import_common34.toWeb3Pk)(args.user),
+      vault: (0, import_common34.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common34.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common34.toWeb3Pk)(args.vaultTrancheState) : null,
+      assetMint: (0, import_common34.toWeb3Pk)(args.assetMint),
+      shareMint: (0, import_common34.toWeb3Pk)(args.shareMint),
+      userAssetAta: (0, import_common34.toWeb3Pk)(args.userAssetAta),
+      vaultAssetAta: (0, import_common34.toWeb3Pk)(args.vaultAssetAta),
+      feeVault: (0, import_common34.toWeb3Pk)(args.feeVault),
+      feeVaultAta: (0, import_common34.toWeb3Pk)(args.feeVaultAta),
+      userShareAta: (0, import_common34.toWeb3Pk)(args.userShareAta),
+      assetTokenProgram: (0, import_common34.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common34.toWeb3Pk)(args.shareTokenProgram)
     };
   }
   getIxData(args) {
@@ -16218,7 +16606,7 @@ var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
     ) : this.program.methods.executeWithdraw(data.shareAmount);
     return methods.accountsPartial(
       this.getIxAccounts(args)
-    ).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common31.toKitInstruction);
+    ).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common34.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -16252,7 +16640,7 @@ var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
       ),
       this.account.fetchVault(txArgs.vault)
     ]);
-    const vaultAssetAta = (0, import_common31.getAtaAddress)(
+    const vaultAssetAta = (0, import_common34.getAtaAddress)(
       txArgs.assetMint,
       txArgs.vault,
       assetTokenProgram,
@@ -16276,19 +16664,19 @@ var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
       vaultTrancheState: vaultTrancheState ?? null,
       assetMint: txArgs.assetMint,
       shareMint: txArgs.shareMint,
-      shareAmount: new import_core11.BN(txArgs.shareAmount.toString()),
+      shareAmount: new import_core12.BN(txArgs.shareAmount.toString()),
       assetTokenProgram,
       shareTokenProgram,
-      userAssetAta: txArgs.userAssetAta ?? (0, import_common31.getAtaAddress)(txArgs.assetMint, txArgs.user, assetTokenProgram),
+      userAssetAta: txArgs.userAssetAta ?? (0, import_common34.getAtaAddress)(txArgs.assetMint, txArgs.user, assetTokenProgram),
       vaultAssetAta,
       feeVault,
-      feeVaultAta: (0, import_common31.getAtaAddress)(
+      feeVaultAta: (0, import_common34.getAtaAddress)(
         txArgs.assetMint,
         feeVault,
         assetTokenProgram,
         true
       ),
-      userShareAta: txArgs.userShareAta ?? (0, import_common31.getAtaAddress)(txArgs.shareMint, txArgs.user, shareTokenProgram),
+      userShareAta: txArgs.userShareAta ?? (0, import_common34.getAtaAddress)(txArgs.shareMint, txArgs.user, shareTokenProgram),
       externalWithdrawIxRefs,
       externalLiquiditySource,
       externalWithdrawAccounts,
@@ -16299,31 +16687,31 @@ var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
     return txArgs.lookupTables;
   }
   async buildPreambleInstructions(args) {
-    const defaultUserAssetAta = (0, import_common31.getAtaAddress)(
+    const defaultUserAssetAta = (0, import_common34.getAtaAddress)(
       args.assetMint,
       args.user,
       args.assetTokenProgram
     );
-    const payer = (0, import_common31.toWeb3Pk)(args.user);
-    const createUserAssetAta = (0, import_common31.toWeb3Pk)(args.userAssetAta).equals(
-      (0, import_common31.toWeb3Pk)(defaultUserAssetAta)
+    const payer = (0, import_common34.toWeb3Pk)(args.user);
+    const createUserAssetAta = (0, import_common34.toWeb3Pk)(args.userAssetAta).equals(
+      (0, import_common34.toWeb3Pk)(defaultUserAssetAta)
     ) ? (0, import_spl_token12.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common31.toWeb3Pk)(args.userAssetAta),
+      (0, import_common34.toWeb3Pk)(args.userAssetAta),
       payer,
-      (0, import_common31.toWeb3Pk)(args.assetMint),
-      (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common34.toWeb3Pk)(args.assetMint),
+      (0, import_common34.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token12.ASSOCIATED_TOKEN_PROGRAM_ID
     ) : null;
     const createFeeVaultAta = (0, import_spl_token12.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common31.toWeb3Pk)(args.feeVaultAta),
-      (0, import_common31.toWeb3Pk)(args.feeVault),
-      (0, import_common31.toWeb3Pk)(args.assetMint),
-      (0, import_common31.toWeb3Pk)(args.assetTokenProgram),
+      (0, import_common34.toWeb3Pk)(args.feeVaultAta),
+      (0, import_common34.toWeb3Pk)(args.feeVault),
+      (0, import_common34.toWeb3Pk)(args.assetMint),
+      (0, import_common34.toWeb3Pk)(args.assetTokenProgram),
       import_spl_token12.ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    return [createUserAssetAta, createFeeVaultAta].filter((ix) => ix != null).map(import_common31.toKitInstruction);
+    return [createUserAssetAta, createFeeVaultAta].filter((ix) => ix != null).map(import_common34.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -16334,8 +16722,8 @@ var ExecuteWithdrawBuilder = class extends VaultBuilderBase {
 
 // src/client/builders/fulfillJuniorTrancheWithdraw.ts
 var import_spl_token13 = require("@solana/spl-token");
-var import_web314 = require("@solana/web3.js");
-var import_common32 = __toESM(require_dist());
+var import_web316 = require("@solana/web3.js");
+var import_common35 = __toESM(require_dist());
 var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     const externalWithdrawIxRefs = args.externalWithdrawIxRefs ?? null;
@@ -16349,24 +16737,24 @@ var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
       externalLiquiditySource
     );
     return methods.accountsPartial({
-      signer: (0, import_common32.toWeb3Pk)(args.signer),
-      owner: (0, import_common32.toWeb3Pk)(args.owner),
-      queuePayer: (0, import_common32.toWeb3Pk)(args.queuePayer),
-      vault: (0, import_common32.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common32.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: (0, import_common32.toWeb3Pk)(args.vaultTrancheState),
-      withdrawalQueue: (0, import_common32.toWeb3Pk)(args.withdrawalQueue),
-      outputMint: (0, import_common32.toWeb3Pk)(args.outputMint),
-      inputMint: (0, import_common32.toWeb3Pk)(args.inputMint),
-      ownerInputAta: (0, import_common32.toWeb3Pk)(args.ownerInputAta),
-      ownerOutputAta: (0, import_common32.toWeb3Pk)(args.ownerOutputAta),
-      vaultOutputAta: (0, import_common32.toWeb3Pk)(args.vaultOutputAta),
-      queueInputAta: (0, import_common32.toWeb3Pk)(args.queueInputAta),
-      assetTokenProgram: (0, import_common32.toWeb3Pk)(args.assetTokenProgram),
-      shareTokenProgram: (0, import_common32.toWeb3Pk)(args.shareTokenProgram),
+      signer: (0, import_common35.toWeb3Pk)(args.signer),
+      owner: (0, import_common35.toWeb3Pk)(args.owner),
+      queuePayer: (0, import_common35.toWeb3Pk)(args.queuePayer),
+      vault: (0, import_common35.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common35.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: (0, import_common35.toWeb3Pk)(args.vaultTrancheState),
+      withdrawalQueue: (0, import_common35.toWeb3Pk)(args.withdrawalQueue),
+      outputMint: (0, import_common35.toWeb3Pk)(args.outputMint),
+      inputMint: (0, import_common35.toWeb3Pk)(args.inputMint),
+      ownerInputAta: (0, import_common35.toWeb3Pk)(args.ownerInputAta),
+      ownerOutputAta: (0, import_common35.toWeb3Pk)(args.ownerOutputAta),
+      vaultOutputAta: (0, import_common35.toWeb3Pk)(args.vaultOutputAta),
+      queueInputAta: (0, import_common35.toWeb3Pk)(args.queueInputAta),
+      assetTokenProgram: (0, import_common35.toWeb3Pk)(args.assetTokenProgram),
+      shareTokenProgram: (0, import_common35.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token13.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web314.SystemProgram.programId
-    }).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common32.toKitInstruction);
+      systemProgram: import_web316.SystemProgram.programId
+    }).remainingAccounts(args.externalWithdrawAccounts.map(toWeb3AccountMeta)).instruction().then(import_common35.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -16407,7 +16795,7 @@ var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
     ]);
     const { mint: juniorShareMint, tokenProgram: shareTokenProgram } = juniorShare;
     const queuePda = txArgs.withdrawalQueue ?? withdrawalQueue;
-    const vaultOutputAta = (0, import_common32.getAtaAddress)(
+    const vaultOutputAta = (0, import_common35.getAtaAddress)(
       txArgs.assetMint,
       txArgs.vault,
       assetTokenProgram,
@@ -16436,14 +16824,14 @@ var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
       inputMint: juniorShareMint,
       assetTokenProgram,
       shareTokenProgram,
-      ownerInputAta: txArgs.ownerInputAta ?? (0, import_common32.getAtaAddress)(juniorShareMint, txArgs.owner, shareTokenProgram),
-      ownerOutputAta: (0, import_common32.getAtaAddress)(
+      ownerInputAta: txArgs.ownerInputAta ?? (0, import_common35.getAtaAddress)(juniorShareMint, txArgs.owner, shareTokenProgram),
+      ownerOutputAta: (0, import_common35.getAtaAddress)(
         txArgs.assetMint,
         txArgs.owner,
         assetTokenProgram
       ),
       vaultOutputAta,
-      queueInputAta: (0, import_common32.getAtaAddress)(
+      queueInputAta: (0, import_common35.getAtaAddress)(
         juniorShareMint,
         queuePda,
         shareTokenProgram,
@@ -16459,22 +16847,22 @@ var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
     return txArgs.lookupTables;
   }
   async buildPreambleInstructions(args) {
-    const defaultOwnerInputAta = (0, import_common32.getAtaAddress)(
+    const defaultOwnerInputAta = (0, import_common35.getAtaAddress)(
       args.inputMint,
       args.owner,
       args.shareTokenProgram
     );
-    if (!(0, import_common32.toWeb3Pk)(args.ownerInputAta).equals((0, import_common32.toWeb3Pk)(defaultOwnerInputAta))) {
+    if (!(0, import_common35.toWeb3Pk)(args.ownerInputAta).equals((0, import_common35.toWeb3Pk)(defaultOwnerInputAta))) {
       return [];
     }
     return [
-      (0, import_common32.toKitInstruction)(
+      (0, import_common35.toKitInstruction)(
         (0, import_spl_token13.createAssociatedTokenAccountIdempotentInstruction)(
-          (0, import_common32.toWeb3Pk)(args.signer),
-          (0, import_common32.toWeb3Pk)(args.ownerInputAta),
-          (0, import_common32.toWeb3Pk)(args.owner),
-          (0, import_common32.toWeb3Pk)(args.inputMint),
-          (0, import_common32.toWeb3Pk)(args.shareTokenProgram),
+          (0, import_common35.toWeb3Pk)(args.signer),
+          (0, import_common35.toWeb3Pk)(args.ownerInputAta),
+          (0, import_common35.toWeb3Pk)(args.owner),
+          (0, import_common35.toWeb3Pk)(args.inputMint),
+          (0, import_common35.toWeb3Pk)(args.shareTokenProgram),
           import_spl_token13.ASSOCIATED_TOKEN_PROGRAM_ID
         )
       )
@@ -16494,8 +16882,8 @@ var FulfillJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/updateTrancheConfig.ts
-var import_core12 = require("@anchor-lang/core");
-var import_common33 = __toESM(require_dist());
+var import_core13 = require("@anchor-lang/core");
+var import_common36 = __toESM(require_dist());
 var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.vaultUpdateTrancheConfig({
@@ -16506,11 +16894,11 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
       targetLockupDurationSecs: args.targetLockupDurationSecs,
       juniorDepositCap: args.juniorDepositCap
     }).accountsPartial({
-      curator: (0, import_common33.toWeb3Pk)(args.curator),
-      vault: (0, import_common33.toWeb3Pk)(args.vault),
-      vaultTrancheState: (0, import_common33.toWeb3Pk)(args.vaultTrancheState),
-      vaultOracle: (0, import_common33.toWeb3Pk)(args.vaultOracle)
-    }).instruction().then(import_common33.toKitInstruction);
+      curator: (0, import_common36.toWeb3Pk)(args.curator),
+      vault: (0, import_common36.toWeb3Pk)(args.vault),
+      vaultTrancheState: (0, import_common36.toWeb3Pk)(args.vaultTrancheState),
+      vaultOracle: (0, import_common36.toWeb3Pk)(args.vaultOracle)
+    }).instruction().then(import_common36.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const [vaultTrancheState] = await this.pda.deriveVaultTrancheStatePda(
@@ -16526,8 +16914,8 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
       juniorFloorApyBps: txArgs.juniorFloorApyBps ?? null,
       earlyUnstakeFeeBps: txArgs.earlyUnstakeFeeBps ?? null,
       standardUnstakeFeeBps: txArgs.standardUnstakeFeeBps ?? null,
-      targetLockupDurationSecs: txArgs.targetLockupDurationSecs === void 0 ? null : new import_core12.BN(txArgs.targetLockupDurationSecs.toString()),
-      juniorDepositCap: txArgs.juniorDepositCap === void 0 ? null : new import_core12.BN(txArgs.juniorDepositCap.toString())
+      targetLockupDurationSecs: txArgs.targetLockupDurationSecs === void 0 ? null : new import_core13.BN(txArgs.targetLockupDurationSecs.toString()),
+      juniorDepositCap: txArgs.juniorDepositCap === void 0 ? null : new import_core13.BN(txArgs.juniorDepositCap.toString())
     };
   }
   async buildPlanExtras(args) {
@@ -16540,25 +16928,25 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/managerRedepositAsset.ts
-var import_core13 = require("@anchor-lang/core");
+var import_core14 = require("@anchor-lang/core");
 var import_spl_token14 = require("@solana/spl-token");
-var import_web315 = require("@solana/web3.js");
-var import_common34 = __toESM(require_dist());
+var import_web317 = require("@solana/web3.js");
+var import_common37 = __toESM(require_dist());
 var ManagerRedepositAssetBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.managerRedepositAsset({
       depositAmount: args.depositAmount,
       externalAmount: args.externalAmount
     }).accountsPartial({
-      manager: (0, import_common34.toWeb3Pk)(args.manager),
-      vault: (0, import_common34.toWeb3Pk)(args.vault),
-      assetMint: (0, import_common34.toWeb3Pk)(args.assetMint),
-      vaultAssetAta: (0, import_common34.toWeb3Pk)(args.vaultAssetAta),
-      managerAssetAta: (0, import_common34.toWeb3Pk)(args.managerAssetAta),
-      assetTokenProgram: (0, import_common34.toWeb3Pk)(args.assetTokenProgram),
+      manager: (0, import_common37.toWeb3Pk)(args.manager),
+      vault: (0, import_common37.toWeb3Pk)(args.vault),
+      assetMint: (0, import_common37.toWeb3Pk)(args.assetMint),
+      vaultAssetAta: (0, import_common37.toWeb3Pk)(args.vaultAssetAta),
+      managerAssetAta: (0, import_common37.toWeb3Pk)(args.managerAssetAta),
+      assetTokenProgram: (0, import_common37.toWeb3Pk)(args.assetTokenProgram),
       associatedTokenProgram: import_spl_token14.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web315.SystemProgram.programId
-    }).instruction().then(import_common34.toKitInstruction);
+      systemProgram: import_web317.SystemProgram.programId
+    }).instruction().then(import_common37.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -16572,10 +16960,10 @@ var ManagerRedepositAssetBuilder = class extends VaultBuilderBase {
       manager: txArgs.manager,
       vault: txArgs.vault,
       assetMint: txArgs.assetMint,
-      depositAmount: new import_core13.BN(txArgs.depositAmount.toString()),
-      externalAmount: new import_core13.BN(externalAmount.toString()),
+      depositAmount: new import_core14.BN(txArgs.depositAmount.toString()),
+      externalAmount: new import_core14.BN(externalAmount.toString()),
       assetTokenProgram,
-      vaultAssetAta: (0, import_common34.getAtaAddress)(
+      vaultAssetAta: (0, import_common37.getAtaAddress)(
         txArgs.assetMint,
         txArgs.vault,
         assetTokenProgram,
@@ -16583,7 +16971,7 @@ var ManagerRedepositAssetBuilder = class extends VaultBuilderBase {
       ),
       // The manager may be a PDA (e.g. a Squads vault), so allow off-curve
       // owners when deriving its ATA.
-      managerAssetAta: (0, import_common34.getAtaAddress)(
+      managerAssetAta: (0, import_common37.getAtaAddress)(
         txArgs.assetMint,
         txArgs.manager,
         assetTokenProgram,
@@ -16599,23 +16987,23 @@ var ManagerRedepositAssetBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/managerWithdrawAsset.ts
-var import_core14 = require("@anchor-lang/core");
+var import_core15 = require("@anchor-lang/core");
 var import_spl_token15 = require("@solana/spl-token");
-var import_web316 = require("@solana/web3.js");
-var import_common35 = __toESM(require_dist());
+var import_web318 = require("@solana/web3.js");
+var import_common38 = __toESM(require_dist());
 var ManagerWithdrawAssetBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.managerWithdrawAsset(args.amount).accountsPartial({
-      manager: (0, import_common35.toWeb3Pk)(args.manager),
-      vault: (0, import_common35.toWeb3Pk)(args.vault),
-      assetMint: (0, import_common35.toWeb3Pk)(args.assetMint),
-      vaultAssetAta: (0, import_common35.toWeb3Pk)(args.vaultAssetAta),
-      destination: (0, import_common35.toWeb3Pk)(args.destination),
-      destinationAssetAta: (0, import_common35.toWeb3Pk)(args.destinationAssetAta),
-      assetTokenProgram: (0, import_common35.toWeb3Pk)(args.assetTokenProgram),
+      manager: (0, import_common38.toWeb3Pk)(args.manager),
+      vault: (0, import_common38.toWeb3Pk)(args.vault),
+      assetMint: (0, import_common38.toWeb3Pk)(args.assetMint),
+      vaultAssetAta: (0, import_common38.toWeb3Pk)(args.vaultAssetAta),
+      destination: (0, import_common38.toWeb3Pk)(args.destination),
+      destinationAssetAta: (0, import_common38.toWeb3Pk)(args.destinationAssetAta),
+      assetTokenProgram: (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
       associatedTokenProgram: import_spl_token15.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web316.SystemProgram.programId
-    }).instruction().then(import_common35.toKitInstruction);
+      systemProgram: import_web318.SystemProgram.programId
+    }).instruction().then(import_common38.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const connection = this.program.provider.connection;
@@ -16630,15 +17018,15 @@ var ManagerWithdrawAssetBuilder = class extends VaultBuilderBase {
       vault: txArgs.vault,
       assetMint: txArgs.assetMint,
       destination,
-      amount: new import_core14.BN(txArgs.amount.toString()),
+      amount: new import_core15.BN(txArgs.amount.toString()),
       assetTokenProgram,
-      vaultAssetAta: (0, import_common35.getAtaAddress)(
+      vaultAssetAta: (0, import_common38.getAtaAddress)(
         txArgs.assetMint,
         txArgs.vault,
         assetTokenProgram,
         true
       ),
-      destinationAssetAta: (0, import_common35.getAtaAddress)(
+      destinationAssetAta: (0, import_common38.getAtaAddress)(
         txArgs.assetMint,
         destination,
         assetTokenProgram,
@@ -16655,18 +17043,18 @@ var ManagerWithdrawAssetBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/protocolInteraction.ts
-var import_core15 = require("@anchor-lang/core");
+var import_core16 = require("@anchor-lang/core");
 var import_kit8 = require("@solana/kit");
 var import_spl_token16 = require("@solana/spl-token");
-var import_web317 = require("@solana/web3.js");
-var import_common36 = __toESM(require_dist());
+var import_web319 = require("@solana/web3.js");
+var import_common39 = __toESM(require_dist());
 var DEFAULT_PYTH_PRICE_MAX_AGE_SECS = 90n;
 function toAssetPriceOracleConfig(args) {
   return {
     priceOracleType: args?.priceOracleType ?? { none: {} },
-    initialPrice: new import_core15.BN((args?.initialPrice ?? 0n).toString()),
+    initialPrice: new import_core16.BN((args?.initialPrice ?? 0n).toString()),
     priceOracleAccount: args?.priceOracleAccount ?? DEFAULT_PRICE_ORACLE_ACCOUNT,
-    pythMaxAgeSecs: new import_core15.BN(
+    pythMaxAgeSecs: new import_core16.BN(
       (args?.pythMaxAgeSecs ?? DEFAULT_PYTH_PRICE_MAX_AGE_SECS).toString()
     )
   };
@@ -16674,12 +17062,12 @@ function toAssetPriceOracleConfig(args) {
 function toAnchorAssetPriceOracleConfig(config) {
   return {
     ...config,
-    priceOracleAccount: (0, import_common36.toWeb3Pk)(config.priceOracleAccount)
+    priceOracleAccount: (0, import_common39.toWeb3Pk)(config.priceOracleAccount)
   };
 }
 function toWeb3AccountMeta2(account) {
   return {
-    pubkey: new import_web317.PublicKey(account.address),
+    pubkey: new import_web319.PublicKey(account.address),
     isWritable: account.role === import_kit8.AccountRole.WRITABLE || account.role === import_kit8.AccountRole.WRITABLE_SIGNER,
     isSigner: account.role === import_kit8.AccountRole.READONLY_SIGNER || account.role === import_kit8.AccountRole.WRITABLE_SIGNER
   };
@@ -16688,14 +17076,14 @@ var ProtocolInteractionBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.protocolInteraction(args.refs, {
       externalLiquidityIndex: args.externalLiquidityIndex,
-      affectedAssetMint: args.affectedAssetMint ? (0, import_common36.toWeb3Pk)(args.affectedAssetMint) : null
+      affectedAssetMint: args.affectedAssetMint ? (0, import_common39.toWeb3Pk)(args.affectedAssetMint) : null
     }).accountsPartial({
-      hwManager: (0, import_common36.toWeb3Pk)(args.hwManager),
-      vault: (0, import_common36.toWeb3Pk)(args.vault),
-      affectedAssetMint: args.affectedAssetMint ? (0, import_common36.toWeb3Pk)(args.affectedAssetMint) : null,
-      affectedVaultAta: args.affectedVaultAta ? (0, import_common36.toWeb3Pk)(args.affectedVaultAta) : null,
-      affectedTokenProgram: args.affectedTokenProgram ? (0, import_common36.toWeb3Pk)(args.affectedTokenProgram) : null
-    }).remainingAccounts(args.accounts.map(toWeb3AccountMeta2)).instruction().then(import_common36.toKitInstruction);
+      hwManager: (0, import_common39.toWeb3Pk)(args.hwManager),
+      vault: (0, import_common39.toWeb3Pk)(args.vault),
+      affectedAssetMint: args.affectedAssetMint ? (0, import_common39.toWeb3Pk)(args.affectedAssetMint) : null,
+      affectedVaultAta: args.affectedVaultAta ? (0, import_common39.toWeb3Pk)(args.affectedVaultAta) : null,
+      affectedTokenProgram: args.affectedTokenProgram ? (0, import_common39.toWeb3Pk)(args.affectedTokenProgram) : null
+    }).remainingAccounts(args.accounts.map(toWeb3AccountMeta2)).instruction().then(import_common39.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const affectedTokenProgram = txArgs.affectedAssetMint ? txArgs.affectedTokenProgram ?? TOKEN_PROGRAM_ID : null;
@@ -16707,7 +17095,7 @@ var ProtocolInteractionBuilder = class extends VaultBuilderBase {
       accounts: txArgs.accounts,
       affectedAssetMint: txArgs.affectedAssetMint ?? null,
       affectedTokenProgram,
-      affectedVaultAta: txArgs.affectedAssetMint && affectedTokenProgram ? (0, import_common36.getAtaAddress)(
+      affectedVaultAta: txArgs.affectedAssetMint && affectedTokenProgram ? (0, import_common39.getAtaAddress)(
         txArgs.affectedAssetMint,
         txArgs.vault,
         affectedTokenProgram,
@@ -16726,18 +17114,18 @@ var JupiterSwapBuilder = class extends VaultBuilderBase {
         args.destinationPriceOracle
       )
     }).accountsPartial({
-      hwManager: (0, import_common36.toWeb3Pk)(args.hwManager),
-      vault: (0, import_common36.toWeb3Pk)(args.vault),
-      sourceMint: (0, import_common36.toWeb3Pk)(args.sourceMint),
-      destinationMint: (0, import_common36.toWeb3Pk)(args.destinationMint),
-      vaultSourceAta: (0, import_common36.toWeb3Pk)(args.vaultSourceAta),
-      vaultDestinationAta: (0, import_common36.toWeb3Pk)(args.vaultDestinationAta),
-      sourceTokenProgram: (0, import_common36.toWeb3Pk)(args.sourceTokenProgram),
-      destinationTokenProgram: (0, import_common36.toWeb3Pk)(args.destinationTokenProgram),
-      destinationOracleAccount: args.destinationOracleAccount ? (0, import_common36.toWeb3Pk)(args.destinationOracleAccount) : null,
-      vaultOracle: (0, import_common36.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: args.vaultTrancheState ? (0, import_common36.toWeb3Pk)(args.vaultTrancheState) : null
-    }).remainingAccounts(args.accounts.map(toWeb3AccountMeta2)).instruction().then(import_common36.toKitInstruction);
+      hwManager: (0, import_common39.toWeb3Pk)(args.hwManager),
+      vault: (0, import_common39.toWeb3Pk)(args.vault),
+      sourceMint: (0, import_common39.toWeb3Pk)(args.sourceMint),
+      destinationMint: (0, import_common39.toWeb3Pk)(args.destinationMint),
+      vaultSourceAta: (0, import_common39.toWeb3Pk)(args.vaultSourceAta),
+      vaultDestinationAta: (0, import_common39.toWeb3Pk)(args.vaultDestinationAta),
+      sourceTokenProgram: (0, import_common39.toWeb3Pk)(args.sourceTokenProgram),
+      destinationTokenProgram: (0, import_common39.toWeb3Pk)(args.destinationTokenProgram),
+      destinationOracleAccount: args.destinationOracleAccount ? (0, import_common39.toWeb3Pk)(args.destinationOracleAccount) : null,
+      vaultOracle: (0, import_common39.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: args.vaultTrancheState ? (0, import_common39.toWeb3Pk)(args.vaultTrancheState) : null
+    }).remainingAccounts(args.accounts.map(toWeb3AccountMeta2)).instruction().then(import_common39.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const sourceTokenProgram = txArgs.sourceTokenProgram ?? TOKEN_PROGRAM_ID;
@@ -16758,13 +17146,13 @@ var JupiterSwapBuilder = class extends VaultBuilderBase {
       accounts: txArgs.accounts,
       sourceTokenProgram,
       destinationTokenProgram,
-      vaultSourceAta: (0, import_common36.getAtaAddress)(
+      vaultSourceAta: (0, import_common39.getAtaAddress)(
         txArgs.sourceMint,
         txArgs.vault,
         sourceTokenProgram,
         true
       ),
-      vaultDestinationAta: (0, import_common36.getAtaAddress)(
+      vaultDestinationAta: (0, import_common39.getAtaAddress)(
         txArgs.destinationMint,
         txArgs.vault,
         destinationTokenProgram,
@@ -16773,24 +17161,24 @@ var JupiterSwapBuilder = class extends VaultBuilderBase {
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common36.toWeb3Pk)(args.hwManager);
+    const payer = (0, import_common39.toWeb3Pk)(args.hwManager);
     const createSourceAta = (0, import_spl_token16.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common36.toWeb3Pk)(args.vaultSourceAta),
-      (0, import_common36.toWeb3Pk)(args.vault),
-      (0, import_common36.toWeb3Pk)(args.sourceMint),
-      (0, import_common36.toWeb3Pk)(args.sourceTokenProgram),
+      (0, import_common39.toWeb3Pk)(args.vaultSourceAta),
+      (0, import_common39.toWeb3Pk)(args.vault),
+      (0, import_common39.toWeb3Pk)(args.sourceMint),
+      (0, import_common39.toWeb3Pk)(args.sourceTokenProgram),
       import_spl_token16.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createDestinationAta = (0, import_spl_token16.createAssociatedTokenAccountIdempotentInstruction)(
       payer,
-      (0, import_common36.toWeb3Pk)(args.vaultDestinationAta),
-      (0, import_common36.toWeb3Pk)(args.vault),
-      (0, import_common36.toWeb3Pk)(args.destinationMint),
-      (0, import_common36.toWeb3Pk)(args.destinationTokenProgram),
+      (0, import_common39.toWeb3Pk)(args.vaultDestinationAta),
+      (0, import_common39.toWeb3Pk)(args.vault),
+      (0, import_common39.toWeb3Pk)(args.destinationMint),
+      (0, import_common39.toWeb3Pk)(args.destinationTokenProgram),
       import_spl_token16.ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    return [createSourceAta, createDestinationAta].map(import_common36.toKitInstruction);
+    return [createSourceAta, createDestinationAta].map(import_common39.toKitInstruction);
   }
   async buildLookupTables(_args, txArgs) {
     return txArgs.lookupTables;
@@ -16823,27 +17211,27 @@ var JupiterSwapBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/requestJuniorTrancheWithdraw.ts
-var import_core16 = require("@anchor-lang/core");
+var import_core17 = require("@anchor-lang/core");
 var import_spl_token17 = require("@solana/spl-token");
-var import_web318 = require("@solana/web3.js");
-var import_common37 = __toESM(require_dist());
+var import_web320 = require("@solana/web3.js");
+var import_common40 = __toESM(require_dist());
 var RequestJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
   async getIx(args) {
     return this.program.methods.requestJuniorTrancheWithdraw(args.queueId, args.shareAmount).accountsPartial({
-      user: (0, import_common37.toWeb3Pk)(args.user),
-      payer: (0, import_common37.toWeb3Pk)(args.payer),
-      vault: (0, import_common37.toWeb3Pk)(args.vault),
-      vaultOracle: (0, import_common37.toWeb3Pk)(args.vaultOracle),
-      vaultTrancheState: (0, import_common37.toWeb3Pk)(args.vaultTrancheState),
-      withdrawalQueue: (0, import_common37.toWeb3Pk)(args.withdrawalQueue),
-      outputMint: (0, import_common37.toWeb3Pk)(args.outputMint),
-      inputMint: (0, import_common37.toWeb3Pk)(args.inputMint),
-      userInputAta: (0, import_common37.toWeb3Pk)(args.userInputAta),
-      queueInputAta: (0, import_common37.toWeb3Pk)(args.queueInputAta),
-      shareTokenProgram: (0, import_common37.toWeb3Pk)(args.shareTokenProgram),
+      user: (0, import_common40.toWeb3Pk)(args.user),
+      payer: (0, import_common40.toWeb3Pk)(args.payer),
+      vault: (0, import_common40.toWeb3Pk)(args.vault),
+      vaultOracle: (0, import_common40.toWeb3Pk)(args.vaultOracle),
+      vaultTrancheState: (0, import_common40.toWeb3Pk)(args.vaultTrancheState),
+      withdrawalQueue: (0, import_common40.toWeb3Pk)(args.withdrawalQueue),
+      outputMint: (0, import_common40.toWeb3Pk)(args.outputMint),
+      inputMint: (0, import_common40.toWeb3Pk)(args.inputMint),
+      userInputAta: (0, import_common40.toWeb3Pk)(args.userInputAta),
+      queueInputAta: (0, import_common40.toWeb3Pk)(args.queueInputAta),
+      shareTokenProgram: (0, import_common40.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token17.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web318.SystemProgram.programId
-    }).instruction().then(import_common37.toKitInstruction);
+      systemProgram: import_web320.SystemProgram.programId
+    }).instruction().then(import_common40.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const payer = txArgs.payer ?? txArgs.user;
@@ -16877,10 +17265,10 @@ var RequestJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
       outputMint: txArgs.assetMint,
       inputMint: juniorShareMint,
       queueId: txArgs.queueId,
-      shareAmount: new import_core16.BN(txArgs.shareAmount.toString()),
+      shareAmount: new import_core17.BN(txArgs.shareAmount.toString()),
       shareTokenProgram,
-      userInputAta: txArgs.userInputAta ?? (0, import_common37.getAtaAddress)(juniorShareMint, txArgs.user, shareTokenProgram),
-      queueInputAta: (0, import_common37.getAtaAddress)(
+      userInputAta: txArgs.userInputAta ?? (0, import_common40.getAtaAddress)(juniorShareMint, txArgs.user, shareTokenProgram),
+      queueInputAta: (0, import_common40.getAtaAddress)(
         juniorShareMint,
         queuePda,
         shareTokenProgram,
@@ -16902,17 +17290,17 @@ var RequestJuniorTrancheWithdrawBuilder = class extends VaultBuilderBase {
 };
 
 // src/client/builders/vaultReallocation.ts
-var import_core17 = require("@anchor-lang/core");
+var import_core18 = require("@anchor-lang/core");
 var import_spl_token18 = require("@solana/spl-token");
-var import_web319 = require("@solana/web3.js");
-var import_common38 = __toESM(require_dist());
+var import_web321 = require("@solana/web3.js");
+var import_common41 = __toESM(require_dist());
 var DEFAULT_PYTH_PRICE_MAX_AGE_SECS2 = 90n;
 function toAssetPriceOracleConfig2(args) {
   return {
     priceOracleType: args?.priceOracleType ?? { none: {} },
-    initialPrice: new import_core17.BN((args?.initialPrice ?? 0n).toString()),
+    initialPrice: new import_core18.BN((args?.initialPrice ?? 0n).toString()),
     priceOracleAccount: args?.priceOracleAccount ?? DEFAULT_PRICE_ORACLE_ACCOUNT,
-    pythMaxAgeSecs: new import_core17.BN(
+    pythMaxAgeSecs: new import_core18.BN(
       (args?.pythMaxAgeSecs ?? DEFAULT_PYTH_PRICE_MAX_AGE_SECS2).toString()
     )
   };
@@ -16920,7 +17308,7 @@ function toAssetPriceOracleConfig2(args) {
 function toAnchorAssetPriceOracleConfig2(config) {
   return {
     ...config,
-    priceOracleAccount: (0, import_common38.toWeb3Pk)(config.priceOracleAccount)
+    priceOracleAccount: (0, import_common41.toWeb3Pk)(config.priceOracleAccount)
   };
 }
 var VaultReallocationBuilder = class extends VaultBuilderBase {
@@ -16929,35 +17317,35 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
       amount: args.amount,
       assetPriceOracle: toAnchorAssetPriceOracleConfig2(args.assetPriceOracle)
     }).accountsPartial({
-      manager: (0, import_common38.toWeb3Pk)(args.manager),
-      allocationVault: (0, import_common38.toWeb3Pk)(args.allocationVault),
-      sourceVault: args.sourceVault ? (0, import_common38.toWeb3Pk)(args.sourceVault) : null,
-      sourceVaultOracle: args.sourceVaultOracle ? (0, import_common38.toWeb3Pk)(args.sourceVaultOracle) : null,
-      destinationVault: (0, import_common38.toWeb3Pk)(args.destinationVault),
-      destinationVaultOracle: (0, import_common38.toWeb3Pk)(args.destinationVaultOracle),
-      mint: (0, import_common38.toWeb3Pk)(args.mint),
-      sourceShareMint: args.sourceShareMint ? (0, import_common38.toWeb3Pk)(args.sourceShareMint) : null,
-      destinationShareMint: (0, import_common38.toWeb3Pk)(args.destinationShareMint),
-      allocationMintAta: (0, import_common38.toWeb3Pk)(args.allocationMintAta),
-      sourceVaultMintAta: args.sourceVaultMintAta ? (0, import_common38.toWeb3Pk)(args.sourceVaultMintAta) : null,
-      destinationVaultMintAta: (0, import_common38.toWeb3Pk)(args.destinationVaultMintAta),
-      destinationFeeVault: (0, import_common38.toWeb3Pk)(args.destinationFeeVault),
-      destinationFeeVaultMintAta: (0, import_common38.toWeb3Pk)(args.destinationFeeVaultMintAta),
-      allocationSourceShareAta: args.allocationSourceShareAta ? (0, import_common38.toWeb3Pk)(args.allocationSourceShareAta) : null,
-      allocationDestinationShareAta: (0, import_common38.toWeb3Pk)(
+      manager: (0, import_common41.toWeb3Pk)(args.manager),
+      allocationVault: (0, import_common41.toWeb3Pk)(args.allocationVault),
+      sourceVault: args.sourceVault ? (0, import_common41.toWeb3Pk)(args.sourceVault) : null,
+      sourceVaultOracle: args.sourceVaultOracle ? (0, import_common41.toWeb3Pk)(args.sourceVaultOracle) : null,
+      destinationVault: (0, import_common41.toWeb3Pk)(args.destinationVault),
+      destinationVaultOracle: (0, import_common41.toWeb3Pk)(args.destinationVaultOracle),
+      mint: (0, import_common41.toWeb3Pk)(args.mint),
+      sourceShareMint: args.sourceShareMint ? (0, import_common41.toWeb3Pk)(args.sourceShareMint) : null,
+      destinationShareMint: (0, import_common41.toWeb3Pk)(args.destinationShareMint),
+      allocationMintAta: (0, import_common41.toWeb3Pk)(args.allocationMintAta),
+      sourceVaultMintAta: args.sourceVaultMintAta ? (0, import_common41.toWeb3Pk)(args.sourceVaultMintAta) : null,
+      destinationVaultMintAta: (0, import_common41.toWeb3Pk)(args.destinationVaultMintAta),
+      destinationFeeVault: (0, import_common41.toWeb3Pk)(args.destinationFeeVault),
+      destinationFeeVaultMintAta: (0, import_common41.toWeb3Pk)(args.destinationFeeVaultMintAta),
+      allocationSourceShareAta: args.allocationSourceShareAta ? (0, import_common41.toWeb3Pk)(args.allocationSourceShareAta) : null,
+      allocationDestinationShareAta: (0, import_common41.toWeb3Pk)(
         args.allocationDestinationShareAta
       ),
-      sourceVaultTrancheState: args.sourceVaultTrancheState ? (0, import_common38.toWeb3Pk)(args.sourceVaultTrancheState) : null,
-      destinationVaultTrancheState: args.destinationVaultTrancheState ? (0, import_common38.toWeb3Pk)(args.destinationVaultTrancheState) : null,
-      assetOracleAccount: args.assetOracleAccount ? (0, import_common38.toWeb3Pk)(args.assetOracleAccount) : null,
-      assetTokenProgram: (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
-      sourceShareTokenProgram: (0, import_common38.toWeb3Pk)(args.sourceShareTokenProgram),
-      destinationShareTokenProgram: (0, import_common38.toWeb3Pk)(
+      sourceVaultTrancheState: args.sourceVaultTrancheState ? (0, import_common41.toWeb3Pk)(args.sourceVaultTrancheState) : null,
+      destinationVaultTrancheState: args.destinationVaultTrancheState ? (0, import_common41.toWeb3Pk)(args.destinationVaultTrancheState) : null,
+      assetOracleAccount: args.assetOracleAccount ? (0, import_common41.toWeb3Pk)(args.assetOracleAccount) : null,
+      assetTokenProgram: (0, import_common41.toWeb3Pk)(args.assetTokenProgram),
+      sourceShareTokenProgram: (0, import_common41.toWeb3Pk)(args.sourceShareTokenProgram),
+      destinationShareTokenProgram: (0, import_common41.toWeb3Pk)(
         args.destinationShareTokenProgram
       ),
       associatedTokenProgram: import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID,
-      systemProgram: import_web319.SystemProgram.programId
-    }).instruction().then(import_common38.toKitInstruction);
+      systemProgram: import_web321.SystemProgram.programId
+    }).instruction().then(import_common41.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
     const assetTokenProgram = txArgs.assetTokenProgram ?? TOKEN_PROGRAM_ID;
@@ -16982,7 +17370,7 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
       mint: txArgs.mint,
       sourceShareMint,
       destinationShareMint: txArgs.destinationShareMint,
-      amount: new import_core17.BN(txArgs.amount.toString()),
+      amount: new import_core18.BN(txArgs.amount.toString()),
       assetPriceOracle: toAssetPriceOracleConfig2(txArgs.assetPriceOracle),
       sourceVaultTrancheState: txArgs.sourceVaultTrancheState ?? null,
       destinationVaultTrancheState: txArgs.destinationVaultTrancheState ?? null,
@@ -16990,33 +17378,33 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
       assetTokenProgram,
       sourceShareTokenProgram,
       destinationShareTokenProgram,
-      allocationMintAta: (0, import_common38.getAtaAddress)(
+      allocationMintAta: (0, import_common41.getAtaAddress)(
         txArgs.mint,
         txArgs.allocationVault,
         assetTokenProgram,
         true
       ),
-      sourceVaultMintAta: sourceVault ? (0, import_common38.getAtaAddress)(txArgs.mint, sourceVault, assetTokenProgram, true) : null,
-      destinationVaultMintAta: (0, import_common38.getAtaAddress)(
+      sourceVaultMintAta: sourceVault ? (0, import_common41.getAtaAddress)(txArgs.mint, sourceVault, assetTokenProgram, true) : null,
+      destinationVaultMintAta: (0, import_common41.getAtaAddress)(
         txArgs.mint,
         txArgs.destinationVault,
         assetTokenProgram,
         true
       ),
       destinationFeeVault,
-      destinationFeeVaultMintAta: (0, import_common38.getAtaAddress)(
+      destinationFeeVaultMintAta: (0, import_common41.getAtaAddress)(
         txArgs.mint,
         destinationFeeVault,
         assetTokenProgram,
         true
       ),
-      allocationSourceShareAta: sourceShareMint && sourceVault ? (0, import_common38.getAtaAddress)(
+      allocationSourceShareAta: sourceShareMint && sourceVault ? (0, import_common41.getAtaAddress)(
         sourceShareMint,
         txArgs.allocationVault,
         sourceShareTokenProgram,
         true
       ) : null,
-      allocationDestinationShareAta: (0, import_common38.getAtaAddress)(
+      allocationDestinationShareAta: (0, import_common41.getAtaAddress)(
         txArgs.destinationShareMint,
         txArgs.allocationVault,
         destinationShareTokenProgram,
@@ -17025,38 +17413,38 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
     };
   }
   async buildPreambleInstructions(args) {
-    const payer = (0, import_common38.toWeb3Pk)(args.manager);
+    const payer = (0, import_common41.toWeb3Pk)(args.manager);
     const instructions2 = [
       (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common38.toWeb3Pk)(args.allocationMintAta),
-        (0, import_common38.toWeb3Pk)(args.allocationVault),
-        (0, import_common38.toWeb3Pk)(args.mint),
-        (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
+        (0, import_common41.toWeb3Pk)(args.allocationMintAta),
+        (0, import_common41.toWeb3Pk)(args.allocationVault),
+        (0, import_common41.toWeb3Pk)(args.mint),
+        (0, import_common41.toWeb3Pk)(args.assetTokenProgram),
         import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
       ),
       (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common38.toWeb3Pk)(args.destinationVaultMintAta),
-        (0, import_common38.toWeb3Pk)(args.destinationVault),
-        (0, import_common38.toWeb3Pk)(args.mint),
-        (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
+        (0, import_common41.toWeb3Pk)(args.destinationVaultMintAta),
+        (0, import_common41.toWeb3Pk)(args.destinationVault),
+        (0, import_common41.toWeb3Pk)(args.mint),
+        (0, import_common41.toWeb3Pk)(args.assetTokenProgram),
         import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
       ),
       (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common38.toWeb3Pk)(args.destinationFeeVaultMintAta),
-        (0, import_common38.toWeb3Pk)(args.destinationFeeVault),
-        (0, import_common38.toWeb3Pk)(args.mint),
-        (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
+        (0, import_common41.toWeb3Pk)(args.destinationFeeVaultMintAta),
+        (0, import_common41.toWeb3Pk)(args.destinationFeeVault),
+        (0, import_common41.toWeb3Pk)(args.mint),
+        (0, import_common41.toWeb3Pk)(args.assetTokenProgram),
         import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
       ),
       (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
-        (0, import_common38.toWeb3Pk)(args.allocationDestinationShareAta),
-        (0, import_common38.toWeb3Pk)(args.allocationVault),
-        (0, import_common38.toWeb3Pk)(args.destinationShareMint),
-        (0, import_common38.toWeb3Pk)(args.destinationShareTokenProgram),
+        (0, import_common41.toWeb3Pk)(args.allocationDestinationShareAta),
+        (0, import_common41.toWeb3Pk)(args.allocationVault),
+        (0, import_common41.toWeb3Pk)(args.destinationShareMint),
+        (0, import_common41.toWeb3Pk)(args.destinationShareTokenProgram),
         import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
       )
     ];
@@ -17064,23 +17452,23 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
       instructions2.push(
         (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
           payer,
-          (0, import_common38.toWeb3Pk)(args.sourceVaultMintAta),
-          (0, import_common38.toWeb3Pk)(args.sourceVault),
-          (0, import_common38.toWeb3Pk)(args.mint),
-          (0, import_common38.toWeb3Pk)(args.assetTokenProgram),
+          (0, import_common41.toWeb3Pk)(args.sourceVaultMintAta),
+          (0, import_common41.toWeb3Pk)(args.sourceVault),
+          (0, import_common41.toWeb3Pk)(args.mint),
+          (0, import_common41.toWeb3Pk)(args.assetTokenProgram),
           import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
         ),
         (0, import_spl_token18.createAssociatedTokenAccountIdempotentInstruction)(
           payer,
-          (0, import_common38.toWeb3Pk)(args.allocationSourceShareAta),
-          (0, import_common38.toWeb3Pk)(args.allocationVault),
-          (0, import_common38.toWeb3Pk)(args.sourceShareMint),
-          (0, import_common38.toWeb3Pk)(args.sourceShareTokenProgram),
+          (0, import_common41.toWeb3Pk)(args.allocationSourceShareAta),
+          (0, import_common41.toWeb3Pk)(args.allocationVault),
+          (0, import_common41.toWeb3Pk)(args.sourceShareMint),
+          (0, import_common41.toWeb3Pk)(args.sourceShareTokenProgram),
           import_spl_token18.ASSOCIATED_TOKEN_PROGRAM_ID
         )
       );
     }
-    return instructions2.map(import_common38.toKitInstruction);
+    return instructions2.map(import_common41.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -17118,6 +17506,13 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
 // src/client/transaction.ts
 var TransactionClient = class {
   constructor(context) {
+    this.createIncentiveV3 = new CreateIncentiveV3Builder(context);
+    this.addIncentiveRecipientV3 = new AddIncentiveRecipientV3Builder(context);
+    this.setIncentiveLimitsV3 = new SetIncentiveLimitsV3Builder(context);
+    this.reportIncentiveV3 = new ReportIncentiveV3Builder(context);
+    this.settleIncentiveV3 = new SettleIncentiveV3Builder(context);
+    this.claimIncentiveV3 = new ClaimIncentiveV3Builder(context);
+    this.distributeIncentiveV3 = new DistributeIncentiveV3Builder(context);
     this.claimIncentive = new ClaimIncentiveBuilder(context);
     this.createIncentive = new CreateIncentiveBuilder(context);
     this.addIncentiveRecipient = new AddIncentiveRecipientBuilder(context);
@@ -17171,7 +17566,7 @@ var VaultClient = class {
     this.provider = provider;
     this.skipSimulation = options.skipSimulation ?? false;
     const idl = { ...IDL, address: programId };
-    this.program = new import_core18.Program(idl, provider);
+    this.program = new import_core19.Program(idl, provider);
     this.pda = new PdaClient((0, import_kit9.address)(this.program.programId.toBase58()));
     const rpc = createRpcFromConnection(provider.connection);
     this.account = new AccountClient(this.program, this.pda, rpc);
@@ -17193,8 +17588,8 @@ var VaultClient = class {
    */
   async sendTransaction(payer, plan, extraSigners = []) {
     const { blockhash, lastValidBlockHeight } = await this.provider.connection.getLatestBlockhash("confirmed");
-    const tx = new import_web320.Transaction().add(
-      ...plan.instructions.map(import_common39.fromKitInstruction)
+    const tx = new import_web322.Transaction().add(
+      ...plan.instructions.map(import_common42.fromKitInstruction)
     );
     tx.feePayer = payer.publicKey;
     tx.recentBlockhash = blockhash;
@@ -17228,13 +17623,13 @@ var VaultClient = class {
     const { blockhash } = await this.provider.connection.getLatestBlockhash(
       "confirmed"
     );
-    const lookupTableAccounts = plan.lookupTables?.length ? await (0, import_common39.fetchLookupTables)(this.provider.connection, plan.lookupTables) : [];
-    const message2 = new import_web320.TransactionMessage({
+    const lookupTableAccounts = plan.lookupTables?.length ? await (0, import_common42.fetchLookupTables)(this.provider.connection, plan.lookupTables) : [];
+    const message2 = new import_web322.TransactionMessage({
       payerKey: payer.publicKey,
       recentBlockhash: blockhash,
-      instructions: plan.instructions.map(import_common39.fromKitInstruction)
+      instructions: plan.instructions.map(import_common42.fromKitInstruction)
     }).compileToV0Message(lookupTableAccounts);
-    const tx = new import_web320.VersionedTransaction(message2);
+    const tx = new import_web322.VersionedTransaction(message2);
     const result = await this.provider.connection.simulateTransaction(tx, {
       sigVerify: false,
       commitment: "processed"
@@ -17308,7 +17703,7 @@ function resolveKeypairPath(keypairPath) {
 }
 function loadKeypair(keypairPath) {
   const raw = import_fs.default.readFileSync(resolveKeypairPath(keypairPath), "utf-8");
-  return import_web321.Keypair.fromSecretKey(new Uint8Array(JSON.parse(raw)));
+  return import_web323.Keypair.fromSecretKey(new Uint8Array(JSON.parse(raw)));
 }
 var ENV_AGNOSTIC_ROLES = /* @__PURE__ */ new Set(["fulfiller", "rebalancer"]);
 function defaultKeypairPath(env, role = "vault") {
@@ -17319,8 +17714,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_web321.Connection(opts.rpcUrl ?? getRpcUrl(env), "confirmed");
-  const provider = new import_core19.AnchorProvider(connection, new import_core19.Wallet(payer), {
+  const connection = new import_web323.Connection(opts.rpcUrl ?? getRpcUrl(env), "confirmed");
+  const provider = new import_core20.AnchorProvider(connection, new import_core20.Wallet(payer), {
     commitment: "confirmed"
   });
   const client = new VaultClient(
@@ -17333,11 +17728,11 @@ function createVaultClient(env, opts = {}) {
     client,
     provider,
     payer,
-    signer: (0, import_common40.fromWeb3Pk)(payer.publicKey)
+    signer: (0, import_common43.fromWeb3Pk)(payer.publicKey)
   };
 }
 function keypairAddress(keypairPath) {
-  return (0, import_common40.fromWeb3Pk)(loadKeypair(keypairPath).publicKey);
+  return (0, import_common43.fromWeb3Pk)(loadKeypair(keypairPath).publicKey);
 }
 
 // src/utils/math.ts
@@ -17351,16 +17746,16 @@ function fromUiAmount(amount, decimals) {
 }
 
 // src/utils/provider.ts
-var import_core20 = require("@anchor-lang/core");
+var import_core21 = require("@anchor-lang/core");
 function makeProvider(connection, payer) {
-  return new import_core20.AnchorProvider(connection, new import_core20.Wallet(payer), {
+  return new import_core21.AnchorProvider(connection, new import_core21.Wallet(payer), {
     commitment: "confirmed"
   });
 }
 
 // src/utils/squads.ts
 var squads = __toESM(require("@sqds/multisig"));
-var import_web322 = require("@solana/web3.js");
+var import_web324 = require("@solana/web3.js");
 var SQUADS_SIMULATION_COMMITMENT = "processed";
 var SquadsProposalExecutionSimulationError = class extends Error {
   constructor(transactionError, logs, unitsConsumed) {
@@ -17384,8 +17779,8 @@ function validateVaultIndex(vaultIndex) {
 }
 function resolveSquadsWalletRoute(route) {
   validateVaultIndex(route.vaultIndex);
-  const wallet = new import_web322.PublicKey(route.wallet);
-  const multisigPda = new import_web322.PublicKey(route.multisigPda);
+  const wallet = new import_web324.PublicKey(route.wallet);
+  const multisigPda = new import_web324.PublicKey(route.multisigPda);
   const [vaultPda] = squads.getVaultPda({
     multisigPda,
     index: route.vaultIndex
@@ -17393,7 +17788,7 @@ function resolveSquadsWalletRoute(route) {
   return { ...route, wallet, multisigPda, vaultPda };
 }
 function findSquadsWalletRoute(wallet, routes) {
-  const walletKey = typeof wallet === "string" ? new import_web322.PublicKey(wallet) : wallet;
+  const walletKey = typeof wallet === "string" ? new import_web324.PublicKey(wallet) : wallet;
   const route = routes.find(
     (candidate) => candidate.wallet === walletKey.toBase58()
   );
@@ -17411,18 +17806,18 @@ function validateSquadsWalletRoutes(routes) {
   }
 }
 function vaultAuthorityForWallet(wallet, routes) {
-  const walletKey = typeof wallet === "string" ? new import_web322.PublicKey(wallet) : wallet;
+  const walletKey = typeof wallet === "string" ? new import_web324.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_web322.TransactionMessage({
+  const message2 = new import_web324.TransactionMessage({
     payerKey: feePayer,
     recentBlockhash,
     instructions: [...instructions2]
   }).compileToV0Message(args.addressLookupTableAccounts);
-  const transaction = new import_web322.VersionedTransaction(message2);
+  const transaction = new import_web324.VersionedTransaction(message2);
   const { value } = await connection.simulateTransaction(transaction, {
     sigVerify: false,
     commitment: SQUADS_SIMULATION_COMMITMENT,
@@ -17443,7 +17838,7 @@ async function prepareVaultTransaction(args) {
   if (!route) {
     return {
       kind: "direct",
-      transaction: new import_web322.Transaction().add(...instructions2),
+      transaction: new import_web324.Transaction().add(...instructions2),
       authority: proposer
     };
   }
@@ -17478,7 +17873,7 @@ async function prepareVaultTransaction(args) {
       addressLookupTableAccounts: args.addressLookupTableAccounts
     });
   }
-  const transactionMessage = new import_web322.TransactionMessage({
+  const transactionMessage = new import_web324.TransactionMessage({
     payerKey: route.vaultPda,
     recentBlockhash: blockhash,
     instructions: [...instructions2]
@@ -17508,7 +17903,7 @@ async function prepareVaultTransaction(args) {
   });
   return {
     kind: "squads",
-    transaction: new import_web322.Transaction().add(
+    transaction: new import_web324.Transaction().add(
       createVaultTransactionIx,
       createProposalIx
     ),
@@ -17523,16 +17918,16 @@ async function prepareVaultTransaction(args) {
 
 // src/utils/squadsBuffer.ts
 var squads2 = __toESM(require("@sqds/multisig"));
-var import_web323 = require("@solana/web3.js");
+var import_web325 = 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_web323.Transaction({
+  const sizeProbe = new import_web325.Transaction({
     feePayer: proposer,
-    recentBlockhash: import_web323.PublicKey.default.toBase58()
+    recentBlockhash: import_web325.PublicKey.default.toBase58()
   }).add(...transaction.instructions);
   let fits = false;
   try {
@@ -17552,7 +17947,7 @@ async function prepareSquadsProposalUpload(args) {
   let bufferPda;
   let bufferIndex = 0;
   for (; bufferIndex <= 255; bufferIndex++) {
-    const [candidate] = import_web323.PublicKey.findProgramAddressSync(
+    const [candidate] = import_web325.PublicKey.findProgramAddressSync(
       [
         Buffer.from("multisig"),
         prepared.multisigPda.toBuffer(),
@@ -17580,7 +17975,7 @@ async function prepareSquadsProposalUpload(args) {
     creator: proposer
   };
   const setupTransactions = [
-    new import_web323.Transaction().add(
+    new import_web325.Transaction().add(
       squads2.generated.createTransactionBufferCreateInstruction(
         {
           ...accounts2,
@@ -17600,7 +17995,7 @@ async function prepareSquadsProposalUpload(args) {
   ];
   for (let offset = BufferChunkSize; offset < bytes.length; offset += BufferChunkSize) {
     setupTransactions.push(
-      new import_web323.Transaction().add(
+      new import_web325.Transaction().add(
         squads2.generated.createTransactionBufferExtendInstruction(accounts2, {
           args: { buffer: bytes.slice(offset, offset + BufferChunkSize) }
         })
@@ -17613,7 +18008,7 @@ async function prepareSquadsProposalUpload(args) {
       vaultTransactionCreateItemTransaction: prepared.vaultTransactionPda,
       vaultTransactionCreateItemCreator: proposer,
       vaultTransactionCreateItemRentPayer: proposer,
-      vaultTransactionCreateItemSystemProgram: import_web323.SystemProgram.programId,
+      vaultTransactionCreateItemSystemProgram: import_web325.SystemProgram.programId,
       transactionBuffer: bufferPda,
       creator: proposer
     },
@@ -17625,7 +18020,7 @@ async function prepareSquadsProposalUpload(args) {
   ).isWritable = true;
   return {
     setupTransactions,
-    proposalTransaction: new import_web323.Transaction().add(
+    proposalTransaction: new import_web325.Transaction().add(
       finalize,
       ...transaction.instructions.slice(1)
     ),
@@ -17636,13 +18031,13 @@ async function prepareSquadsProposalUpload(args) {
 
 // src/utils/token.ts
 var import_spl_token19 = require("@solana/spl-token");
-var import_web324 = require("@solana/web3.js");
-var import_common41 = __toESM(require_dist());
+var import_web326 = require("@solana/web3.js");
+var import_common44 = __toESM(require_dist());
 async function createTokenMintIxs(connection, payer, authority, decimals, tokenProgram = import_spl_token19.TOKEN_2022_PROGRAM_ID) {
-  const mint = import_web324.Keypair.generate();
+  const mint = import_web326.Keypair.generate();
   const lamports = await (0, import_spl_token19.getMinimumBalanceForRentExemptMint)(connection);
   const ixs = [
-    import_web324.SystemProgram.createAccount({
+    import_web326.SystemProgram.createAccount({
       fromPubkey: payer,
       newAccountPubkey: mint.publicKey,
       space: import_spl_token19.MINT_SIZE,
@@ -17668,7 +18063,7 @@ async function createTokenMint(connection, payer, decimals, tokenProgram = impor
     tokenProgram
   );
   const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-  const tx = new import_web324.Transaction().add(...ixs);
+  const tx = new import_web326.Transaction().add(...ixs);
   tx.feePayer = payer.publicKey;
   tx.recentBlockhash = blockhash;
   tx.sign(payer, mint);
@@ -17682,7 +18077,7 @@ async function createTokenMint(connection, payer, decimals, tokenProgram = impor
   return mint.publicKey;
 }
 async function mintTokensTo(connection, payer, mint, destination, amount, tokenProgram = import_spl_token19.TOKEN_2022_PROGRAM_ID, allowOwnerOffCurve = true) {
-  const tokenProgramPk = (0, import_common41.asWeb3PublicKey)(tokenProgram);
+  const tokenProgramPk = (0, import_common44.asWeb3PublicKey)(tokenProgram);
   const ata = (0, import_spl_token19.getAssociatedTokenAddressSync)(
     mint,
     destination,
@@ -17707,12 +18102,12 @@ async function mintTokensTo(connection, payer, mint, destination, amount, tokenP
       tokenProgramPk
     )
   ];
-  const tx = new import_web324.Transaction().add(...ixs);
+  const tx = new import_web326.Transaction().add(...ixs);
   await connection.sendTransaction(tx, [payer]);
 }
 
 // src/utils/yieldApi.ts
-var import_core21 = require("@anchor-lang/core");
+var import_core22 = 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 = {
@@ -18038,7 +18433,7 @@ async function getTrackedValue(accountName) {
   return trackedValueFromResponse(await getYield(accountName));
 }
 async function getTotalYield(accountNames, start, end) {
-  let totalYield = new import_core21.BN(0);
+  let totalYield = new import_core22.BN(0);
   for (const accountName of accountNames) {
     const res = await getYield(accountName, start, end);
     if (isNavAccountValue(res)) {
@@ -18047,7 +18442,7 @@ async function getTotalYield(accountNames, start, end) {
       );
     }
     console.log(res);
-    totalYield = totalYield.add(new import_core21.BN(res.total_yield));
+    totalYield = totalYield.add(new import_core22.BN(res.total_yield));
   }
   return totalYield;
 }
@@ -18079,7 +18474,7 @@ async function getTotalTrackedValue(accountNames, start, end) {
 }
 
 // src/services/withdrawalQueueService.ts
-var import_common42 = __toESM(require_dist());
+var import_common45 = __toESM(require_dist());
 function bnToBigInt(value) {
   return BigInt(value.toString());
 }
@@ -18100,7 +18495,7 @@ var WithdrawalQueueService = class {
     const program = this.client.program.account;
     const accounts2 = await program.vaultWithdrawalQueue.all();
     return accounts2.map(
-      (entry) => this.toSnapshot((0, import_common42.fromWeb3Pk)(entry.publicKey), entry.account)
+      (entry) => this.toSnapshot((0, import_common45.fromWeb3Pk)(entry.publicKey), entry.account)
     );
   }
   /** Withdrawal queues for a single vault. */
@@ -18141,7 +18536,7 @@ var WithdrawalQueueService = class {
   async fulfill(signer, queue) {
     const plan = await this.client.tx.fulfillJuniorTrancheWithdraw.getTx({
       owner: queue.owner,
-      signer: (0, import_common42.fromWeb3Pk)(signer.publicKey),
+      signer: (0, import_common45.fromWeb3Pk)(signer.publicKey),
       queuePayer: queue.payer,
       vault: queue.vault,
       withdrawalQueue: queue.pda,
@@ -18195,12 +18590,12 @@ var WithdrawalQueueService = class {
     const a = account;
     return {
       pda,
-      vault: (0, import_common42.fromWeb3Pk)(a.parties.vault),
-      owner: (0, import_common42.fromWeb3Pk)(a.parties.owner),
-      payer: (0, import_common42.fromWeb3Pk)(a.parties.payer),
+      vault: (0, import_common45.fromWeb3Pk)(a.parties.vault),
+      owner: (0, import_common45.fromWeb3Pk)(a.parties.owner),
+      payer: (0, import_common45.fromWeb3Pk)(a.parties.payer),
       queueId: a.header.queueId,
-      inputMint: (0, import_common42.fromWeb3Pk)(a.mints.inputMint),
-      outputMint: (0, import_common42.fromWeb3Pk)(a.mints.outputMint),
+      inputMint: (0, import_common45.fromWeb3Pk)(a.mints.inputMint),
+      outputMint: (0, import_common45.fromWeb3Pk)(a.mints.outputMint),
       inputAmount: bnToBigInt(a.request.inputAmount),
       requestTs: bnToNumber(a.request.requestTs),
       expiryTs: bnToNumber(a.request.expiryTs)
@@ -18210,10 +18605,10 @@ var WithdrawalQueueService = class {
 
 // src/services/oracleService.ts
 var import_kit11 = require("@solana/kit");
-var import_common43 = __toESM(require_dist());
-var SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var import_common46 = __toESM(require_dist());
+var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
 var DEFAULT_PRICE_STALENESS_THRESHOLD_SECS2 = 86400n;
-var PRICE_ORACLE_TYPES_BY_INDEX = [
+var PRICE_ORACLE_TYPES_BY_INDEX2 = [
   "none",
   "consensusOracle",
   "pyth",
@@ -18234,14 +18629,14 @@ function pubkeyString2(value) {
   return String(value);
 }
 function isZeroPubkey(value) {
-  return !value || value === SYSTEM_PROGRAM || /^1+$/.test(value);
+  return !value || value === SYSTEM_PROGRAM2 || /^1+$/.test(value);
 }
 function variantName(value) {
   if (typeof value === "number") {
-    return PRICE_ORACLE_TYPES_BY_INDEX[value] ?? String(value);
+    return PRICE_ORACLE_TYPES_BY_INDEX2[value] ?? String(value);
   }
   if (typeof value === "bigint") {
-    return PRICE_ORACLE_TYPES_BY_INDEX[Number(value)] ?? String(value);
+    return PRICE_ORACLE_TYPES_BY_INDEX2[Number(value)] ?? String(value);
   }
   if (value && typeof value === "object") return Object.keys(value)[0] ?? "";
   return String(value ?? "");
@@ -18274,7 +18669,7 @@ var OracleService = class {
    */
   async updateAssetConsensusPrice(signer, args, log) {
     const plan = await this.client.tx.updateConsensusOracle.getTx({
-      signer: (0, import_common43.fromWeb3Pk)(signer.publicKey),
+      signer: (0, import_common46.fromWeb3Pk)(signer.publicKey),
       vault: args.vault,
       updates: args.updates,
       assetMint: args.assetMint,
@@ -18290,7 +18685,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_common43.fromWeb3Pk)(cranker.publicKey),
+      cranker: (0, import_common46.fromWeb3Pk)(cranker.publicKey),
       vault: args.vault,
       vaultTrancheState: args.vaultTrancheState
     });
@@ -18363,7 +18758,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_common43.fromWeb3Pk)(updater.publicKey),
+      updater: (0, import_common46.fromWeb3Pk)(updater.publicKey),
       vault: args.vault,
       mint: args.mint,
       oracleAccount: args.oracleAccount,
@@ -18400,31 +18795,6 @@ var OracleService = class {
 // src/services/consensusOracle/types.ts
 var systemClock = { now: () => Date.now() };
 
-// src/services/consensusOracle/constants.ts
-var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
-var PRICE_ORACLE_TYPES_BY_INDEX2 = [
-  "none",
-  "consensusOracle",
-  "pyth",
-  "perenaVault"
-];
-var CONSENSUS_ORACLE_VARIANT = "consensusoracle";
-var LIVE_ORACLE_VARIANTS = /* @__PURE__ */ new Set(["pyth", "perenavault"]);
-var REPORTABLE_ORACLE_VARIANTS = /* @__PURE__ */ new Set([
-  CONSENSUS_ORACLE_VARIANT,
-  ...LIVE_ORACLE_VARIANTS
-]);
-var LIVE_PRICE_REFRESH_INTERVAL_SECS = 60n * 60n;
-var DEFAULT_PRICE_STALENESS_SECS = BigInt(
-  DEFAULT_PRICE_STALENESS_THRESHOLD_SECS
-);
-var EXTERNAL_POSITION_SAMPLES = 5;
-var MIN_EXTERNAL_POSITION_SAMPLES = 4;
-var ORACLE_ENTRY_SIZE = 272;
-var ORACLE_ENTRIES_OFFSET = 40;
-var ORACLE_SETTLED_NAV_TS_OFFSET = 8;
-var MAX_CONSENSUS_SIGNERS = 4;
-
 // src/services/consensusOracle/utils/accountLayout.ts
 function readI64LE(data, offset) {
   let value = 0n;
@@ -18461,10 +18831,10 @@ function signerInOracleData(data, signerBytes) {
 // src/services/consensusOracle/utils/decode.ts
 function variantName2(value) {
   if (typeof value === "number") {
-    return PRICE_ORACLE_TYPES_BY_INDEX2[value] ?? String(value);
+    return PRICE_ORACLE_TYPES_BY_INDEX[value] ?? String(value);
   }
   if (typeof value === "bigint") {
-    return PRICE_ORACLE_TYPES_BY_INDEX2[Number(value)] ?? String(value);
+    return PRICE_ORACLE_TYPES_BY_INDEX[Number(value)] ?? String(value);
   }
   if (value && typeof value === "object") return Object.keys(value)[0] ?? "";
   return String(value ?? "");
@@ -18484,12 +18854,12 @@ function toBigInt2(value) {
 }
 
 // src/services/consensusOracle/utils/holdings.ts
-var import_web325 = require("@solana/web3.js");
-var import_common44 = __toESM(require_dist());
+var import_web327 = require("@solana/web3.js");
+var import_common47 = __toESM(require_dist());
 function selectReportableHoldings(holdings, excludedMints = /* @__PURE__ */ new Set()) {
   return holdings.map((holding, holdingIndex) => ({ holding, holdingIndex })).filter(({ holding }) => {
-    const mint = (0, import_common44.fromWeb3Pk)(holding.mint);
-    return mint !== SYSTEM_PROGRAM2 && !excludedMints.has(mint.toString()) && REPORTABLE_ORACLE_VARIANTS.has(
+    const mint = (0, import_common47.fromWeb3Pk)(holding.mint);
+    return mint !== SYSTEM_PROGRAM && !excludedMints.has(mint.toString()) && REPORTABLE_ORACLE_VARIANTS.has(
       variantName2(holding.priceOracleType).toLowerCase()
     );
   });
@@ -18523,7 +18893,7 @@ function parseExternalLiquidityRefs(vaultState) {
     if (!data || data.length < 40) continue;
     if (data[0] !== 1) continue;
     const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-    const userAccount = new import_web325.PublicKey(pubkeyBytes).toBase58();
+    const userAccount = new import_web327.PublicKey(pubkeyBytes).toBase58();
     refs.push({
       kind: "marginfi",
       mint: "",
@@ -18749,12 +19119,12 @@ function formatBpsAsPercent(bps) {
 }
 
 // src/services/consensusOracle/pipeline/dryRunSettlement.ts
-var import_web327 = require("@solana/web3.js");
-var import_common45 = __toESM(require_dist());
+var import_web329 = require("@solana/web3.js");
+var import_common48 = __toESM(require_dist());
 
 // src/services/consensusOracle/settlement/settlementSimulator.ts
 var import_kit12 = require("@solana/kit");
-var import_web326 = require("@solana/web3.js");
+var import_web328 = require("@solana/web3.js");
 var DEFAULT_SHARE_PRICE = 1000000n;
 var BPS_DENOMINATOR3 = 10000n;
 var NAV_LOSS_TOLERANCE_BPS = 25n;
@@ -18957,7 +19327,7 @@ function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
       continue;
     }
     const reports = entries.filter(
-      (entry) => entry.signer !== import_web326.PublicKey.default.toBase58() && isFresh(entry.lastUpdateTs, nowTs, stalenessThresholdSecs) && (entry.prices[index] ?? 0n) > 0n
+      (entry) => entry.signer !== import_web328.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);
@@ -19455,7 +19825,7 @@ function decodeOracleData(data, nowTs) {
       (_, holdingIndex) => readU64(data, offset + EXTERNAL_OFFSET + holdingIndex * 8)
     );
     entries.push({
-      signer: new import_web326.PublicKey(signerBytes).toBase58(),
+      signer: new import_web328.PublicKey(signerBytes).toBase58(),
       lastUpdateTs: readI64(data, offset + 32),
       prices,
       externalAmounts
@@ -19470,7 +19840,7 @@ function decodeOracleData(data, nowTs) {
         data.slice(pendingOffset + index * 32, pendingOffset + (index + 1) * 32)
       );
       entries[index] = {
-        signer: index < pendingCount ? new import_web326.PublicKey(signerBytes).toBase58() : import_web326.PublicKey.default.toBase58(),
+        signer: index < pendingCount ? new import_web328.PublicKey(signerBytes).toBase58() : import_web328.PublicKey.default.toBase58(),
         lastUpdateTs: 0n,
         prices: Array(MAX_HOLDINGS).fill(0n),
         externalAmounts: Array(MAX_HOLDINGS).fill(0n)
@@ -19498,7 +19868,7 @@ function decodeHolding(value) {
     externalAmount: bigint(holding.externalAmount),
     price: bigint(holding.price),
     lastUpdateTs: bigint(holding.lastUpdateTs),
-    cleared: mintString === import_web326.PublicKey.default.toBase58()
+    cleared: mintString === import_web328.PublicKey.default.toBase58()
   };
 }
 function decodeTrancheState(decoded, args, warnings, blockers) {
@@ -19963,11 +20333,11 @@ async function simulateDryRunSettlement({
     client.account.fetchVaultOracleForVault(vault, { fresh: true }),
     tranchingEnabled ? client.account.fetchVaultTrancheStateForVault(vault, { fresh: true }) : Promise.resolve(void 0)
   ]);
-  const mintKeys = [new import_web327.PublicKey(vaultState.mint)];
+  const mintKeys = [new import_web329.PublicKey(vaultState.mint)];
   if (trancheState) {
     mintKeys.push(
-      new import_web327.PublicKey(trancheState.config.juniorMint),
-      new import_web327.PublicKey(trancheState.config.seniorMint)
+      new import_web329.PublicKey(trancheState.config.juniorMint),
+      new import_web329.PublicKey(trancheState.config.seniorMint)
     );
   }
   const mintAccounts = await client.provider.connection.getMultipleAccountsInfo(
@@ -19983,7 +20353,7 @@ async function simulateDryRunSettlement({
     oracleData: oracleState.data,
     trancheState,
     updates,
-    signer: (0, import_common45.fromWeb3Pk)(signer.publicKey),
+    signer: (0, import_common48.fromWeb3Pk)(signer.publicKey),
     nowTs: nowSecs,
     physicalShareSupply: supplies[0],
     physicalJuniorSupply: tranchingEnabled ? supplies[1] : void 0,
@@ -19992,7 +20362,7 @@ async function simulateDryRunSettlement({
 }
 
 // src/services/consensusOracle/pipeline/holdingUpdates.ts
-var import_common46 = __toESM(require_dist());
+var import_common49 = __toESM(require_dist());
 async function buildUpdates(yieldTracker, reportableHoldings, inputs) {
   const updates = [];
   for (const entry of reportableHoldings) {
@@ -20002,7 +20372,7 @@ async function buildUpdates(yieldTracker, reportableHoldings, inputs) {
 }
 async function buildHoldingUpdate(yieldTracker, entry, inputs) {
   const { holding, holdingIndex } = entry;
-  const mint = (0, import_common46.fromWeb3Pk)(holding.mint);
+  const mint = (0, import_common49.fromWeb3Pk)(holding.mint);
   const mintKey = mint.toString();
   const oracleType = variantName2(holding.priceOracleType).toLowerCase();
   let usd;
@@ -20064,14 +20434,14 @@ async function resolveTrackedAmounts(yieldTracker, cfg, decimals) {
     );
   }
   return {
-    trackedValueAmount: tracked.totalValue > 0 ? (0, import_common46.fromUiAmount)(tracked.totalValue, decimals) : 0n,
-    principalAmount: tracked.principal > 0 ? (0, import_common46.fromUiAmount)(tracked.principal, decimals) : 0n,
-    yieldAmount: tracked.outstandingYield > 0 ? (0, import_common46.fromUiAmount)(tracked.outstandingYield, decimals) : 0n
+    trackedValueAmount: tracked.totalValue > 0 ? (0, import_common49.fromUiAmount)(tracked.totalValue, decimals) : 0n,
+    principalAmount: tracked.principal > 0 ? (0, import_common49.fromUiAmount)(tracked.principal, decimals) : 0n,
+    yieldAmount: tracked.outstandingYield > 0 ? (0, import_common49.fromUiAmount)(tracked.outstandingYield, decimals) : 0n
   };
 }
 
 // src/services/consensusOracle/pipeline/livePriceRefresh.ts
-var import_common47 = __toESM(require_dist());
+var import_common50 = __toESM(require_dist());
 async function refreshLiveOraclePrices({
   oracle,
   signer,
@@ -20090,8 +20460,8 @@ 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_common47.fromWeb3Pk)(holding.mint);
-    if (mint.toString() === SYSTEM_PROGRAM2) continue;
+    const mint = (0, import_common50.fromWeb3Pk)(holding.mint);
+    if (mint.toString() === SYSTEM_PROGRAM) continue;
     const activeAmount = toBigInt2(holding.localAmount) + toBigInt2(holding.externalAmount);
     if (activeAmount === 0n) continue;
     const lastUpdateTs = toBigInt2(holding.lastUpdateTs);
@@ -20105,8 +20475,8 @@ async function refreshLiveOraclePrices({
       );
       continue;
     }
-    const oracleAccount = (0, import_common47.fromWeb3Pk)(holding.priceOracleAccount);
-    if (oracleAccount.toString() === SYSTEM_PROGRAM2) {
+    const oracleAccount = (0, import_common50.fromWeb3Pk)(holding.priceOracleAccount);
+    if (oracleAccount.toString() === SYSTEM_PROGRAM) {
       log(
         `vault ${vault}: cannot refresh ${mint}; ${oracleType} holding has no oracle account`
       );
@@ -20129,14 +20499,14 @@ async function refreshLiveOraclePrices({
 }
 
 // src/services/consensusOracle/pipeline/pricingInputs.ts
-var import_common48 = __toESM(require_dist());
+var import_common51 = __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_common48.fromWeb3Pk)(holding.mint));
+  ).map(({ holding }) => (0, import_common51.fromWeb3Pk)(holding.mint));
   const baseHolding = vaultState.holdings.find((h) => coerceBool3(h.isBase));
-  const baseMint = baseHolding ? (0, import_common48.fromWeb3Pk)(baseHolding.mint) : consensusMints[0];
+  const baseMint = baseHolding ? (0, import_common51.fromWeb3Pk)(baseHolding.mint) : consensusMints[0];
   if (!baseMint) {
     throw new Error(`vault has no holdings \u2014 cannot determine base asset`);
   }
@@ -20220,11 +20590,11 @@ function reconcilePositionSnapshots(snapshots, vault, log) {
 }
 
 // src/services/consensusOracle/pipeline/receiptMints.ts
-var import_common49 = __toESM(require_dist());
+var import_common52 = __toESM(require_dist());
 async function fetchReceiptMints(client, vault, vaultState) {
   const receiptMints = /* @__PURE__ */ new Set();
   if (vaultState.mint) {
-    receiptMints.add((0, import_common49.fromWeb3Pk)(vaultState.mint).toString());
+    receiptMints.add((0, import_common52.fromWeb3Pk)(vaultState.mint).toString());
   }
   if (!coerceBool3(vaultState.tranchingEnabled)) return receiptMints;
   const trancheState = await client.account.fetchVaultTrancheStateForVault(
@@ -20232,19 +20602,19 @@ async function fetchReceiptMints(client, vault, vaultState) {
     { fresh: true }
   );
   receiptMints.add(
-    (0, import_common49.fromWeb3Pk)(trancheState.config.juniorMint).toString()
+    (0, import_common52.fromWeb3Pk)(trancheState.config.juniorMint).toString()
   );
   receiptMints.add(
-    (0, import_common49.fromWeb3Pk)(trancheState.config.seniorMint).toString()
+    (0, import_common52.fromWeb3Pk)(trancheState.config.seniorMint).toString()
   );
   return receiptMints;
 }
 
 // src/services/consensusOracle/pipeline/settlement.ts
-var import_common51 = __toESM(require_dist());
+var import_common54 = __toESM(require_dist());
 
 // src/services/consensusOracle/pipeline/yieldAccounts.ts
-var import_common50 = __toESM(require_dist());
+var import_common53 = __toESM(require_dist());
 async function assertNoUnconfirmedYieldPayments(yieldTracker, target) {
   const accountNames = [
     ...new Set(
@@ -20286,7 +20656,7 @@ async function withDiscoveredYieldAccounts(yieldTracker, target, vaultState, exc
   );
   if (namesToAttach.length === 0) return target;
   const baseHolding = vaultState.holdings.find((holding) => {
-    const mint = (0, import_common50.fromWeb3Pk)(holding.mint).toString();
+    const mint = (0, import_common53.fromWeb3Pk)(holding.mint).toString();
     return coerceBool3(holding.isBase) && !excludedMints.has(mint);
   });
   if (!baseHolding) {
@@ -20294,7 +20664,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_common50.fromWeb3Pk)(baseHolding.mint);
+  const baseMint = (0, import_common53.fromWeb3Pk)(baseHolding.mint);
   const holdings = [...target.holdings ?? []];
   const existingIndex = holdings.findIndex(
     (holding) => holding.mint.toString() === baseMint.toString()
@@ -20395,8 +20765,8 @@ async function logProspectiveApy({
     );
     const prospectiveNav = vaultState.holdings.reduce(
       (sum, holding, holdingIndex) => {
-        const mint = (0, import_common51.fromWeb3Pk)(holding.mint).toString();
-        if (mint === SYSTEM_PROGRAM2) return sum;
+        const mint = (0, import_common54.fromWeb3Pk)(holding.mint).toString();
+        if (mint === SYSTEM_PROGRAM) return sum;
         const update = updatesByIndex.get(holdingIndex);
         const localAmount = toBigInt2(holding.localAmount);
         const externalAmount = update ? update.externalAmount : toBigInt2(holding.externalAmount);
@@ -20548,7 +20918,7 @@ var StaticPositionProvider = class {
 
 // src/services/consensusOracle/positions/kaminoPositionProvider.ts
 var import_kit14 = require("@solana/kit");
-var import_web328 = require("@solana/web3.js");
+var import_web330 = require("@solana/web3.js");
 var import_klend_sdk = require("@kamino-finance/klend-sdk");
 async function readKaminoBalance(manager, vault, sharesHolder) {
   const userShares = await manager.getUserSharesBalanceSingleVault(
@@ -20585,7 +20955,7 @@ var KaminoPositionProvider = class {
       const amount = await readKaminoBalance(
         manager,
         kVault,
-        new import_web328.PublicKey(sharesHolder)
+        new import_web330.PublicKey(sharesHolder)
       );
       out.push({ mint: ref.mint, amount });
     }
@@ -20594,7 +20964,7 @@ var KaminoPositionProvider = class {
 };
 
 // src/services/consensusOracle/positions/marginfiPositionProvider.ts
-var import_web329 = require("@solana/web3.js");
+var import_web331 = require("@solana/web3.js");
 var import_marginfi2 = __toESM(require_dist2());
 var MarginfiPositionProvider = class {
   constructor(connection, log = () => {
@@ -20605,8 +20975,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_web329.PublicKey(bank));
-    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web329.PublicKey(account));
+    const explicitBanks = refs.map((r) => r.marginfiBank).filter(Boolean).map((bank) => new import_web331.PublicKey(bank));
+    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web331.PublicKey(account));
     const autoBanks = [];
     for (const accountPk of autoAccountPks) {
       try {
@@ -20635,14 +21005,14 @@ var MarginfiPositionProvider = class {
       if (bank) {
         const amount = await (0, import_marginfi2.readMarginfiBankBalance)(
           client,
-          new import_web329.PublicKey(account),
-          new import_web329.PublicKey(bank)
+          new import_web331.PublicKey(account),
+          new import_web331.PublicKey(bank)
         );
         out.push({ mint: ref.mint, amount });
       } else {
         const balances = await (0, import_marginfi2.readAllMarginfiBalances)(
           client,
-          new import_web329.PublicKey(account)
+          new import_web331.PublicKey(account)
         );
         for (const { mint, amount } of balances) {
           out.push({ mint: mint.toBase58(), amount });
@@ -20882,7 +21252,7 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
 }
 
 // src/services/consensusOracle/consensusOracleService.ts
-var import_common52 = __toESM(require_dist());
+var import_common55 = __toESM(require_dist());
 var ConsensusOracleService = class {
   constructor(client, deps) {
     this.client = client;
@@ -20918,7 +21288,7 @@ var ConsensusOracleService = class {
       receiptMints
     );
     const filteredCount = vaultState.holdings.filter(
-      (holding) => receiptMints.has((0, import_common52.fromWeb3Pk)(holding.mint).toString())
+      (holding) => receiptMints.has((0, import_common55.fromWeb3Pk)(holding.mint).toString())
     ).length;
     if (filteredCount > 0) {
       log(
@@ -21099,8 +21469,8 @@ async function runLiveConsensusOracle(env, oracleSigner, opts = {}) {
 
 // src/services/externalLiquidityIntegrityService.ts
 var import_kit15 = require("@solana/kit");
-var import_web330 = require("@solana/web3.js");
-var import_common53 = __toESM(require_dist());
+var import_web332 = require("@solana/web3.js");
+var import_common56 = __toESM(require_dist());
 var import_marginfi3 = __toESM(require_dist2());
 var DEFAULT_MIN_AMOUNT_UI = 1;
 var DEFAULT_TARGET_LOCAL_BPS = 50;
@@ -21122,7 +21492,7 @@ function parseActiveSlots(externalLiquidity) {
     if (discriminant === 0) continue;
     if (discriminant !== 1) continue;
     const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-    const userAccount = (0, import_common53.toAddress)(new import_web330.PublicKey(pubkeyBytes));
+    const userAccount = (0, import_common56.toAddress)(new import_web332.PublicKey(pubkeyBytes));
     results.push({ index: i, source: "marginfi", userAccount });
   }
   return results;
@@ -21238,8 +21608,8 @@ var ExternalLiquidityIntegrityService = class {
       result.skipped++;
       return result;
     }
-    const hwManagerAddress = (0, import_common53.fromWeb3Pk)(hwManager.publicKey);
-    const vaultPk = new import_web330.PublicKey(vault.toString());
+    const hwManagerAddress = (0, import_common56.fromWeb3Pk)(hwManager.publicKey);
+    const vaultPk = new import_web332.PublicKey(vault.toString());
     const registeredHwManager = pubkeyStr(
       vaultState.roles.hwManager
     );
@@ -21359,14 +21729,14 @@ var ExternalLiquidityIntegrityService = class {
     const marginfiClient = new import_marginfi3.CpiClient({
       accounts: marginfiAccounts
     });
-    const { getAtaAddress: getAtaAddress19 } = await Promise.resolve().then(() => __toESM(require_dist()));
-    const vaultAta = getAtaAddress19(
+    const { getAtaAddress: getAtaAddress20 } = await Promise.resolve().then(() => __toESM(require_dist()));
+    const vaultAta = getAtaAddress20(
       mintAddress,
       vault,
       marginfiAccounts.tokenProgram,
       true
     );
-    const cpiRefs = (0, import_common53.createCpiRefs)([
+    const cpiRefs = (0, import_common56.createCpiRefs)([
       direction === "deposit" ? marginfiClient.deposit_cpi({
         marginfiAccount: slot.userAccount,
         authority: vault,
@@ -21420,8 +21790,8 @@ var ExternalLiquidityIntegrityService = class {
 var import_kit16 = require("@solana/kit");
 var import_spl_token20 = require("@solana/spl-token");
 var import_marginfi_client_v2 = require("@mrgnlabs/marginfi-client-v2");
-var import_web331 = require("@solana/web3.js");
-var import_common54 = __toESM(require_dist());
+var import_web333 = require("@solana/web3.js");
+var import_common57 = __toESM(require_dist());
 var import_jupiter2 = __toESM(require_dist3());
 var import_marginfi4 = __toESM(require_dist2());
 var IDLE_RESERVE_FLOOR_BPS = 400;
@@ -21520,8 +21890,8 @@ var IdleLiquidityService = class {
     let quote;
     try {
       quote = await jupiter.getQuote({
-        inputMint: import_common54.PST_MINT,
-        outputMint: import_common54.USDC_MINT,
+        inputMint: import_common57.PST_MINT,
+        outputMint: import_common57.USDC_MINT,
         amount: pstInput,
         slippageBps: opts.slippageBps ?? DEFAULT_SLIPPAGE_BPS,
         maxAccounts: DEFAULT_MAX_ACCOUNTS
@@ -21567,8 +21937,8 @@ var IdleLiquidityService = class {
   /** Read only the two locations that constitute the idle USDC reserve. */
   async fetchIdleUsdc(vault, vaultState) {
     const connection = this.client.provider.connection;
-    const vaultPk = new import_web331.PublicKey(vault);
-    const usdcMint = new import_web331.PublicKey(import_common54.USDC_MINT);
+    const vaultPk = new import_web333.PublicKey(vault);
+    const usdcMint = new import_web333.PublicKey(import_common57.USDC_MINT);
     const ata = (0, import_spl_token20.getAssociatedTokenAddressSync)(usdcMint, vaultPk, true);
     const tokenInfo = await connection.getAccountInfo(ata, "confirmed");
     let localAmount = 0n;
@@ -21587,12 +21957,12 @@ var IdleLiquidityService = class {
     if (data[0] !== 1) {
       throw new Error("External-liquidity slot 0 is not Marginfi");
     }
-    const positionPk = new import_web331.PublicKey(new Uint8Array(data.slice(8, 40)));
+    const positionPk = new import_web333.PublicKey(new Uint8Array(data.slice(8, 40)));
     const positionInfo = await connection.getAccountInfo(
       positionPk,
       "confirmed"
     );
-    if (!positionInfo || !positionInfo.owner.equals(new import_web331.PublicKey(import_marginfi4.MARGINFI_PROGRAM_ID))) {
+    if (!positionInfo || !positionInfo.owner.equals(new import_web333.PublicKey(import_marginfi4.MARGINFI_PROGRAM_ID))) {
       throw new Error(
         `Invalid Marginfi slot-0 account: ${positionPk.toBase58()}`
       );
@@ -21642,8 +22012,8 @@ var IdleLiquidityService = class {
       log(`Vault ${vault}: ${reason} \u2014 skipping`);
       return { result: { ...empty, status: "no-tvl", reason } };
     }
-    const usdc = findHolding2(vaultState, import_common54.USDC_MINT);
-    const pst = findHolding2(vaultState, import_common54.PST_MINT);
+    const usdc = findHolding2(vaultState, import_common57.USDC_MINT);
+    const pst = findHolding2(vaultState, import_common57.PST_MINT);
     if (!usdc || !pst) {
       const reason = `vault has no ${usdc ? "PST" : "USDC"} holding`;
       log(`Vault ${vault}: ${reason} \u2014 skipping`);
@@ -21771,7 +22141,7 @@ var IdleLiquidityService = class {
    */
   async mintTokenProgram(mint) {
     const account = await this.client.provider.connection.getAccountInfo(
-      new import_web331.PublicKey(mint),
+      new import_web333.PublicKey(mint),
       "confirmed"
     );
     if (!account) throw new Error(`Mint account not found: ${mint}`);
@@ -21780,7 +22150,7 @@ var IdleLiquidityService = class {
         `Unsupported token program ${account.owner.toBase58()} for mint ${mint}`
       );
     }
-    return (0, import_common54.fromWeb3Pk)(account.owner);
+    return (0, import_common57.fromWeb3Pk)(account.owner);
   }
   /**
    * Build, simulate, and (unless `dryRun`) submit the `jupiter_swap`.
@@ -21800,23 +22170,23 @@ var IdleLiquidityService = class {
       dryRun,
       log
     } = params;
-    const signer = (0, import_common54.fromWeb3Pk)(hwManager.publicKey);
+    const signer = (0, import_common57.fromWeb3Pk)(hwManager.publicKey);
     const [sourceTokenProgram, destinationTokenProgram] = await Promise.all([
-      this.mintTokenProgram(import_common54.PST_MINT),
-      this.mintTokenProgram(import_common54.USDC_MINT)
+      this.mintTokenProgram(import_common57.PST_MINT),
+      this.mintTokenProgram(import_common57.USDC_MINT)
     ]);
     const jupiterCpi = await jupiter.getSwapCpiData(quote, vault, {
       payer: signer
     });
-    const { accounts: accounts2, refs, lookupTables } = (0, import_common54.createCpiRefs)([jupiterCpi]);
+    const { accounts: accounts2, refs, lookupTables } = (0, import_common57.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_common54.PST_MINT,
-      destinationMint: import_common54.USDC_MINT,
+      sourceMint: import_common57.PST_MINT,
+      destinationMint: import_common57.USDC_MINT,
       refs,
       accounts: accounts2,
       sourceTokenProgram,
@@ -21826,26 +22196,26 @@ var IdleLiquidityService = class {
     });
     const connection = this.client.provider.connection;
     const instructions2 = [
-      import_web331.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNIT_LIMIT }),
+      import_web333.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNIT_LIMIT }),
       ...cuPriceMicroLamports > 0 ? [
-        import_web331.ComputeBudgetProgram.setComputeUnitPrice({
+        import_web333.ComputeBudgetProgram.setComputeUnitPrice({
           microLamports: cuPriceMicroLamports
         })
       ] : [],
-      ...(jupiterCpi.preInstructions ?? []).map(import_common54.fromKitInstruction),
-      ...plan.instructions.map(import_common54.fromKitInstruction)
+      ...(jupiterCpi.preInstructions ?? []).map(import_common57.fromKitInstruction),
+      ...plan.instructions.map(import_common57.fromKitInstruction)
     ];
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-    const lookupTableAccounts = await (0, import_common54.fetchLookupTables)(
+    const lookupTableAccounts = await (0, import_common57.fetchLookupTables)(
       connection,
       plan.lookupTables ?? []
     );
-    const message2 = new import_web331.TransactionMessage({
+    const message2 = new import_web333.TransactionMessage({
       payerKey: hwManager.publicKey,
       recentBlockhash: blockhash,
       instructions: instructions2
     }).compileToV0Message(lookupTableAccounts);
-    const transaction = new import_web331.VersionedTransaction(message2);
+    const transaction = new import_web333.VersionedTransaction(message2);
     transaction.sign([hwManager]);
     if (!this.client.skipSimulation) {
       const simulation = await connection.simulateTransaction(transaction, {
@@ -21891,9 +22261,9 @@ var IdleLiquidityService = class {
 
 // src/services/timelockSettlementService.ts
 var import_kit17 = require("@solana/kit");
-var import_web332 = require("@solana/web3.js");
-var import_common55 = __toESM(require_dist());
-var ZERO_PUBKEY = import_web332.PublicKey.default.toBase58();
+var import_web334 = require("@solana/web3.js");
+var import_common58 = __toESM(require_dist());
+var ZERO_PUBKEY = import_web334.PublicKey.default.toBase58();
 var CONSENSUS_SIGNER_CAPACITY = 4;
 var CONSENSUS_ENTRY_OFFSET = 40;
 var CONSENSUS_ENTRY_SIZE = 272;
@@ -21933,7 +22303,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_web332.PublicKey(bytes.slice(start, start + 32)).toBase58();
+    const signer = new import_web334.PublicKey(bytes.slice(start, start + 32)).toBase58();
     if (signer === ZERO_PUBKEY) {
       throw new Error(`pending consensus signer ${i} is unset`);
     }
@@ -21989,7 +22359,7 @@ var TimelockSettlementService = class {
     });
     const dryRun = opts.dryRun ?? false;
     const now = opts.now ?? await this.chainTime();
-    const fulfillerAddress = (0, import_common55.fromWeb3Pk)(fulfiller.publicKey);
+    const fulfillerAddress = (0, import_common58.fromWeb3Pk)(fulfiller.publicKey);
     const allVaults = opts.vault ? [
       {
         publicKey: opts.vault,
@@ -22133,17 +22503,17 @@ var TimelockSettlementService = class {
 // src/services/nestWithdrawalService.ts
 var import_kit18 = require("@solana/kit");
 var import_spl_token21 = require("@solana/spl-token");
-var import_web333 = require("@solana/web3.js");
-var import_common56 = __toESM(require_dist());
+var import_web335 = require("@solana/web3.js");
+var import_common59 = __toESM(require_dist());
 var import_nest3 = __toESM(require_dist4());
 var import_nest4 = __toESM(require_dist4());
-var NestOftProgram = new import_web333.PublicKey(
+var NestOftProgram = new import_web335.PublicKey(
   "ChEfPd3RzLeYiRwp1K9evimmaFSd6DV1S4Mv5q5Aj1th"
 );
-var NestOftStore = new import_web333.PublicKey(
+var NestOftStore = new import_web335.PublicKey(
   "k8mJj8Gyw2gFAqut21AFVUUZhxb4RVDMnb4PrSYiDhV"
 );
-var UsdcMint = new import_web333.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var UsdcMint = new import_web335.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 var NestPerenaComposer = Buffer.from(
   "000000000000000000000000908dcb5531691c2124c54e30bb645cf11647090d",
   "hex"
@@ -22160,7 +22530,7 @@ async function buildNestWithdrawalRequest(args) {
   return decodeNestWithdrawalRequest({ ...args, txBase64 });
 }
 async function decodeNestWithdrawalRequest(args) {
-  const transaction = import_web333.VersionedTransaction.deserialize(
+  const transaction = import_web335.VersionedTransaction.deserialize(
     Buffer.from(args.txBase64, "base64")
   );
   const message2 = transaction.message;
@@ -22181,14 +22551,14 @@ async function decodeNestWithdrawalRequest(args) {
       return value;
     })
   );
-  const decoded = import_web333.TransactionMessage.decompile(message2, {
+  const decoded = import_web335.TransactionMessage.decompile(message2, {
     addressLookupTableAccounts: tables
   });
-  const nestMint = new import_web333.PublicKey(NEST_RWA_SHARE_MINT);
+  const nestMint = new import_web335.PublicKey(NEST_RWA_SHARE_MINT);
   const sourceAta = (0, import_spl_token21.getAssociatedTokenAddressSync)(nestMint, args.owner, true);
   const usdcAta = (0, import_spl_token21.getAssociatedTokenAddressSync)(UsdcMint, args.owner, true);
   const instructions2 = decoded.instructions.filter(
-    (ix) => !ix.programId.equals(import_web333.ComputeBudgetProgram.programId)
+    (ix) => !ix.programId.equals(import_web335.ComputeBudgetProgram.programId)
   );
   let sends = 0;
   for (const ix of instructions2) {
@@ -22210,13 +22580,13 @@ async function decodeNestWithdrawalRequest(args) {
   if (sends !== 1)
     throw new Error("Nest withdrawal must contain exactly one OFT send");
   return {
-    instructions: instructions2.map(import_common56.toKitInstruction),
+    instructions: instructions2.map(import_common59.toKitInstruction),
     lookupTables: tables.map((table) => (0, import_kit18.address)(table.key.toBase58()))
   };
 }
 
 // src/index.ts
-var import_common57 = __toESM(require_dist());
+var import_common60 = __toESM(require_dist());
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ASSET_DECIMALS,
@@ -22224,16 +22594,19 @@ var import_common57 = __toESM(require_dist());
   AccountClient,
   ActivateCircuitBreakerBuilder,
   AddIncentiveRecipientBuilder,
+  AddIncentiveRecipientV3Builder,
   BALANCE_CHANGE_BASELINE_MAX_AGE_SECS,
   CONSENSUS_ORACLE_VARIANT,
   CancelIncentiveProposalBuilder,
   CancelJuniorTrancheWithdrawBuilder,
   ClaimIncentiveBuilder,
+  ClaimIncentiveV3Builder,
   ConsensusOracleService,
   CrankNavBuilder,
   CrankPerformanceFeesBuilder,
   CreateAssetHoldingBuilder,
   CreateIncentiveBuilder,
+  CreateIncentiveV3Builder,
   CreateTrancheStateBuilder,
   CreateVaultBuilder,
   DEFAULT_CU_PRICE_MICRO_LAMPORTS,
@@ -22254,6 +22627,7 @@ var import_common57 = __toESM(require_dist());
   DEFAULT_VAULT_ID,
   DisableCircuitBreakerBuilder,
   DistributeIncentiveBuilder,
+  DistributeIncentiveV3Builder,
   EXTERNAL_POSITION_SAMPLES,
   ExecuteDepositBuilder,
   ExecuteShareSwapBuilder,
@@ -22281,6 +22655,7 @@ var import_common57 = __toESM(require_dist());
   MAX_BALANCE_CHANGE_BPS,
   MAX_CONSENSUS_SIGNERS,
   MAX_INCENTIVE_RECIPIENTS,
+  MAX_INCENTIVE_REPORT_TTL,
   MAX_MANAGER_WITHDRAW_DESTINATIONS,
   MAX_PRICE_STALENESS_THRESHOLD_SECS,
   MIN_EXTERNAL_POSITION_SAMPLES,
@@ -22306,15 +22681,18 @@ var import_common57 = __toESM(require_dist());
   ProtocolInteractionBuilder,
   REPORTABLE_ORACLE_VARIANTS,
   RemoveAssetHoldingBuilder,
+  ReportIncentiveV3Builder,
   RequestJuniorTrancheWithdrawBuilder,
   SHARE_DECIMALS,
   SYSTEM_PROGRAM,
   SetAssetPriceOracleBuilder,
   SetExternalLiquidityBuilder,
   SetIncentiveLimitsBuilder,
+  SetIncentiveLimitsV3Builder,
   SetManagerWithdrawDestinationBuilder,
   SetProtocolFeeBuilder,
   SetVaultConfigBuilder,
+  SettleIncentiveV3Builder,
   SquadsProposalExecutionSimulationError,
   StaticPositionProvider,
   SubmitIncentiveBuilder,
@@ -22391,6 +22769,10 @@ var import_common57 = __toESM(require_dist());
   getIncentiveRecipients,
   getIncentiveReportRecipients,
   getIncentiveTotals,
+  getIncentiveV3OracleState,
+  getIncentiveV3RecipientShareAtas,
+  getIncentiveV3Recipients,
+  getIncentiveV3Totals,
   getNavValue,
   getRpcUrl,
   getTotalOutstandingYield,