@perena/vault-sdk 1.0.19 → 1.0.23

package/dist/index.js

@@ -233,8 +233,8 @@ var require_roles = __commonJS({
         return kit_1.AccountRole.WRITABLE;
       return role;
     }
-    function stripSignerFromAccounts(accounts) {
-      return accounts.map((acc) => ({
+    function stripSignerFromAccounts(accounts2) {
+      return accounts2.map((acc) => ({
         ...acc,
         role: downgradeRoleFromSigner(acc.role)
       }));
@@ -344,8 +344,8 @@ var require_refs = __commonJS({
     var roles_1 = require_roles();
     var accounts_1 = require_accounts();
     var args_1 = require_args();
-    function buildIndicesForCpi(accounts, poolIndex) {
-      return accounts.map((acc) => {
+    function buildIndicesForCpi(accounts2, poolIndex) {
+      return accounts2.map((acc) => {
         const idx = poolIndex.get(acc.address);
         if (idx === void 0) {
           throw new Error(`Account ${acc.address} not found in pool`);
@@ -355,8 +355,8 @@ var require_refs = __commonJS({
     }
     function buildDeduplicatedPool(accountLists) {
       const poolMap = /* @__PURE__ */ new Map();
-      for (const accounts of accountLists) {
-        for (const acc of accounts) {
+      for (const accounts2 of accountLists) {
+        for (const acc of accounts2) {
           const existing = poolMap.get(acc.address);
           if (!existing) {
             poolMap.set(acc.address, { ...acc });
@@ -380,8 +380,8 @@ var require_refs = __commonJS({
           poolIndex.set(acc.address, i);
         }
       });
-      for (const accounts of accountLists) {
-        for (const acc of accounts) {
+      for (const accounts2 of accountLists) {
+        for (const acc of accounts2) {
           const existingIdx = poolIndex.get(acc.address);
           if (existingIdx === void 0) {
             const idx = pool.length;
@@ -594,27 +594,27 @@ var require_transaction = __commonJS({
     exports2.sendVersionedTransaction = sendVersionedTransaction;
     var web3_js_1 = require("@solana/web3.js");
     async function fetchLookupTables(connection, lookupTables) {
-      const accounts = await Promise.all(lookupTables.map(async (lookupTable) => {
+      const accounts2 = await Promise.all(lookupTables.map(async (lookupTable) => {
         const response = await connection.getAddressLookupTable(new web3_js_1.PublicKey(lookupTable));
         if (!response.value) {
           throw new Error(`Lookup table not found: ${lookupTable}`);
         }
         return response.value;
       }));
-      return accounts;
+      return accounts2;
     }
     async function getSignatureStatus(connection, signature) {
       return (await connection.getSignatureStatuses([signature], {
         searchTransactionHistory: true
       })).value[0];
     }
-    async function sendVersionedTransaction({ connection, payer, instructions, lookupTables }) {
+    async function sendVersionedTransaction({ connection, payer, instructions: instructions2, lookupTables }) {
       const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
       const lookupTableAccounts = await fetchLookupTables(connection, lookupTables);
       const message = new web3_js_1.TransactionMessage({
         payerKey: payer.publicKey,
         recentBlockhash: blockhash,
-        instructions
+        instructions: instructions2
       }).compileToV0Message(lookupTableAccounts);
       const tx = new web3_js_1.VersionedTransaction(message);
       tx.sign([payer]);
@@ -1209,37 +1209,37 @@ var require_cpiClient = __commonJS({
       }
       return value;
     }
-    function orderedDepositAccounts(accounts) {
+    function orderedDepositAccounts(accounts2) {
       return [
-        account(accounts.group, kit_1.AccountRole.READONLY),
-        account(accounts.marginfiAccount, kit_1.AccountRole.WRITABLE),
-        account(accounts.authority, kit_1.AccountRole.READONLY_SIGNER),
-        account(accounts.bank, kit_1.AccountRole.WRITABLE),
-        account(accounts.signerTokenAccount, kit_1.AccountRole.WRITABLE),
-        account(accounts.liquidityVault, kit_1.AccountRole.WRITABLE),
-        account(accounts.tokenProgram, kit_1.AccountRole.READONLY)
+        account(accounts2.group, kit_1.AccountRole.READONLY),
+        account(accounts2.marginfiAccount, kit_1.AccountRole.WRITABLE),
+        account(accounts2.authority, kit_1.AccountRole.READONLY_SIGNER),
+        account(accounts2.bank, kit_1.AccountRole.WRITABLE),
+        account(accounts2.signerTokenAccount, kit_1.AccountRole.WRITABLE),
+        account(accounts2.liquidityVault, kit_1.AccountRole.WRITABLE),
+        account(accounts2.tokenProgram, kit_1.AccountRole.READONLY)
       ];
     }
-    function orderedCreateAccountAccounts(accounts) {
+    function orderedCreateAccountAccounts(accounts2) {
       return [
-        account(accounts.marginfiGroup, kit_1.AccountRole.READONLY),
-        account(accounts.marginfiAccount, kit_1.AccountRole.WRITABLE),
-        account(accounts.authority, kit_1.AccountRole.READONLY_SIGNER),
-        account(accounts.feePayer, kit_1.AccountRole.WRITABLE_SIGNER),
-        account(accounts.instructionsSysvar, kit_1.AccountRole.READONLY),
-        account(accounts.systemProgram, kit_1.AccountRole.READONLY)
+        account(accounts2.marginfiGroup, kit_1.AccountRole.READONLY),
+        account(accounts2.marginfiAccount, kit_1.AccountRole.WRITABLE),
+        account(accounts2.authority, kit_1.AccountRole.READONLY_SIGNER),
+        account(accounts2.feePayer, kit_1.AccountRole.WRITABLE_SIGNER),
+        account(accounts2.instructionsSysvar, kit_1.AccountRole.READONLY),
+        account(accounts2.systemProgram, kit_1.AccountRole.READONLY)
       ];
     }
-    function orderedWithdrawAccounts(accounts) {
+    function orderedWithdrawAccounts(accounts2) {
       return [
-        account(accounts.group, kit_1.AccountRole.WRITABLE),
-        account(accounts.marginfiAccount, kit_1.AccountRole.WRITABLE),
-        account(accounts.authority, kit_1.AccountRole.READONLY_SIGNER),
-        account(accounts.bank, kit_1.AccountRole.WRITABLE),
-        account(accounts.destinationTokenAccount, kit_1.AccountRole.WRITABLE),
-        account(accounts.bankLiquidityVaultAuthority, kit_1.AccountRole.READONLY),
-        account(accounts.liquidityVault, kit_1.AccountRole.WRITABLE),
-        account(accounts.tokenProgram, kit_1.AccountRole.READONLY)
+        account(accounts2.group, kit_1.AccountRole.WRITABLE),
+        account(accounts2.marginfiAccount, kit_1.AccountRole.WRITABLE),
+        account(accounts2.authority, kit_1.AccountRole.READONLY_SIGNER),
+        account(accounts2.bank, kit_1.AccountRole.WRITABLE),
+        account(accounts2.destinationTokenAccount, kit_1.AccountRole.WRITABLE),
+        account(accounts2.bankLiquidityVaultAuthority, kit_1.AccountRole.READONLY),
+        account(accounts2.liquidityVault, kit_1.AccountRole.WRITABLE),
+        account(accounts2.tokenProgram, kit_1.AccountRole.READONLY)
       ];
     }
     var CpiClient = class {
@@ -1249,7 +1249,7 @@ var require_cpiClient = __commonJS({
         this.accounts = config.accounts ?? constants_1.MARGINFI_MAIN_USDC_ACCOUNTS;
       }
       create_account_cpi(params) {
-        const accounts = params.accounts ?? this.createAccountAccounts({
+        const accounts2 = params.accounts ?? this.createAccountAccounts({
           marginfiAccount: params.marginfiAccount,
           authority: params.authority,
           feePayer: params.feePayer
@@ -1258,7 +1258,7 @@ var require_cpiClient = __commonJS({
           cpiType: params.cpiType ?? common_1.CpiTypes.MARGINFI_ACCOUNT_INITIALIZE,
           programId: this.programId,
           accounts: [
-            ...orderedCreateAccountAccounts(accounts),
+            ...orderedCreateAccountAccounts(accounts2),
             ...params.remainingAccounts ?? []
           ],
           data: (0, common_1.encodeU16AndOptionalU16)(params.accountIndex ?? constants_1.MARGINFI_ACCOUNT_INDEX, params.thirdPartyId ?? constants_1.MARGINFI_THIRD_PARTY_ID, "accountIndex", "thirdPartyId"),
@@ -1266,7 +1266,7 @@ var require_cpiClient = __commonJS({
         };
       }
       deposit_cpi(params) {
-        const accounts = params.accounts ?? this.depositAccounts({
+        const accounts2 = params.accounts ?? this.depositAccounts({
           marginfiAccount: params.marginfiAccount,
           authority: params.authority,
           signerTokenAccount: params.signerTokenAccount
@@ -1275,7 +1275,7 @@ var require_cpiClient = __commonJS({
           cpiType: params.cpiType ?? common_1.CpiTypes.MARGINFI_DEPOSIT,
           programId: this.programId,
           accounts: [
-            ...orderedDepositAccounts(accounts),
+            ...orderedDepositAccounts(accounts2),
             ...params.remainingAccounts ?? []
           ],
           data: (0, common_1.encodeU64AndOptionalBool)(params.amount, params.depositUpToLimit),
@@ -1283,7 +1283,7 @@ var require_cpiClient = __commonJS({
         };
       }
       withdraw_cpi(params) {
-        const accounts = params.accounts ?? this.withdrawAccounts({
+        const accounts2 = params.accounts ?? this.withdrawAccounts({
           marginfiAccount: params.marginfiAccount,
           authority: params.authority,
           destinationTokenAccount: params.destinationTokenAccount
@@ -1296,7 +1296,7 @@ var require_cpiClient = __commonJS({
           cpiType: params.cpiType ?? common_1.CpiTypes.MARGINFI_WITHDRAW,
           programId: this.programId,
           accounts: [
-            ...orderedWithdrawAccounts(accounts),
+            ...orderedWithdrawAccounts(accounts2),
             ...params.remainingAccounts ?? [],
             ...bankAndOracleRemainingAccounts
           ],
@@ -1461,35 +1461,44 @@ __export(index_exports, {
   WithdrawalQueueService: () => WithdrawalQueueService,
   addCashflowUpdate: () => addCashflowUpdate,
   address: () => import_kit10.address,
+  confirmYieldPayment: () => confirmYieldPayment,
   createAccount: () => createAccount,
   createLiveConsensusOracleDeps: () => createLiveConsensusOracleDeps,
   createRpcFromConnection: () => createRpcFromConnection,
   createTokenMint: () => createTokenMint,
   createTokenMintIxs: () => createTokenMintIxs,
   createVaultClient: () => createVaultClient,
+  createYieldPayment: () => createYieldPayment,
   dateToStr: () => dateToStr,
   defaultKeypairPath: () => defaultKeypairPath,
   deleteAccount: () => deleteAccount,
+  findSquadsWalletRoute: () => findSquadsWalletRoute,
   fromUiAmount: () => fromUiAmount,
   getAccounts: () => getAccounts,
   getBalance: () => getBalance,
   getCashflows: () => getCashflows,
   getRpcUrl: () => getRpcUrl,
+  getTotalOutstandingYield: () => getTotalOutstandingYield,
   getTotalYield: () => getTotalYield,
   getVaultProgramId: () => getVaultProgramId,
   getYield: () => getYield,
+  getYieldPayments: () => getYieldPayments,
   isVaultEnv: () => isVaultEnv,
   keypairAddress: () => keypairAddress,
   loadKeypair: () => loadKeypair,
   makeProvider: () => makeProvider,
   mintTokensTo: () => mintTokensTo,
+  prepareVaultTransaction: () => prepareVaultTransaction,
   resolveKeypairPath: () => resolveKeypairPath,
+  resolveSquadsWalletRoute: () => resolveSquadsWalletRoute,
   roundToNextUtcMidnight: () => roundToNextUtcMidnight,
   runLiveConsensusOracle: () => runLiveConsensusOracle,
   systemClock: () => systemClock,
   toUiAmount: () => toUiAmount,
   updateAccount: () => updateAccount,
-  updateDynamicApr: () => updateDynamicApr
+  updateDynamicApr: () => updateDynamicApr,
+  validateSquadsWalletRoutes: () => validateSquadsWalletRoutes,
+  vaultAuthorityForWallet: () => vaultAuthorityForWallet
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -11025,219 +11034,239 @@ var IDL = {
   ],
   "errors": [
     {
-      "code": 6e3,
-      "name": "MintSupplyNonZero",
-      "msg": "Supplied share mint already has non-zero supply"
+      "code": 14001,
+      "name": "Unauthorized",
+      "msg": "You are not authorized to perform this action."
     },
     {
-      "code": 6001,
-      "name": "InvalidAssetMint",
-      "msg": "Supplied mint is not accepted by this vault"
+      "code": 14002,
+      "name": "InvalidBankMint",
+      "msg": "Invalid mint"
     },
     {
-      "code": 6002,
-      "name": "ZeroDepositAmount",
-      "msg": "Deposit amount must be greater than zero"
+      "code": 14003,
+      "name": "AccountingIssue",
+      "msg": "Accounting issue"
     },
     {
-      "code": 6003,
-      "name": "ExceedsTvlLimit",
-      "msg": "Deposit would exceed the vault's TVL limit"
+      "code": 14004,
+      "name": "VaultAccountingIssue",
+      "msg": "Vault accounting issue"
     },
     {
-      "code": 6004,
-      "name": "ZeroBurnAmount",
-      "msg": "Burn amount must be greater than zero"
+      "code": 14005,
+      "name": "BankAccountingIssue",
+      "msg": "Bank accounting issue"
     },
     {
-      "code": 6005,
-      "name": "ZeroAssetAmount",
-      "msg": "Asset amount must be greater than zero"
+      "code": 14006,
+      "name": "OnchainAccountingIssue",
+      "msg": "Onchain accounting issue"
     },
     {
-      "code": 6006,
-      "name": "InsufficientVaultLiquidity",
-      "msg": "Insufficient vault liquidity to satisfy withdrawal"
+      "code": 14007,
+      "name": "ExternalAccountingIssue",
+      "msg": "External accounting issue"
     },
     {
-      "code": 6007,
-      "name": "MintAuthorityNotCurator",
-      "msg": "Mint authority is not the curator"
+      "code": 14008,
+      "name": "MintSlippage",
+      "msg": "Minting failed due to slippage."
     },
     {
-      "code": 6008,
-      "name": "ZeroTotalSupply",
-      "msg": "Vault total supply is zero"
+      "code": 14009,
+      "name": "BurningSlippage",
+      "msg": "Burning failed due to slippage."
     },
     {
-      "code": 6009,
+      "code": 14010,
+      "name": "TeamAccountAlreadyExists",
+      "msg": "Team account already exists"
+    },
+    {
+      "code": 14011,
+      "name": "OracleAccountAlreadyExists",
+      "msg": "Oracle account already exists"
+    },
+    {
+      "code": 14012,
       "name": "StaleOracle",
-      "msg": "Vault oracle is stale"
+      "msg": "Stale oracle"
     },
     {
-      "code": 6010,
-      "name": "InvalidOracleUpdate",
-      "msg": "Invalid oracle update"
+      "code": 14013,
+      "name": "LocalSignificantPriceChange",
+      "msg": "Price change is too large locally"
     },
     {
-      "code": 6011,
-      "name": "InvalidInitialMintSharePrice",
-      "msg": "Initial mint share price must be greater than zero"
+      "code": 14014,
+      "name": "SignificantPriceChange",
+      "msg": "Price change is too large"
     },
     {
-      "code": 6012,
-      "name": "MaxApyExceeded",
-      "msg": "Oracle NAV update exceeds the vault's maximum acceptable APY"
+      "code": 14015,
+      "name": "RoundingImpact",
+      "msg": "Rounding impacts the protocol"
     },
     {
-      "code": 6013,
-      "name": "InvalidApyConfig",
-      "msg": "Invalid APY configuration"
+      "code": 14016,
+      "name": "BankIsHalted",
+      "msg": "Bank is halted"
     },
     {
-      "code": 6014,
-      "name": "InvalidFeeConfig",
-      "msg": "Invalid fee configuration"
+      "code": 14017,
+      "name": "VaultIsHalted",
+      "msg": "Vault is halted"
     },
     {
-      "code": 6015,
-      "name": "VaultHasLiveAssets",
-      "msg": "Vault has live supply, TVL, or holdings"
+      "code": 14018,
+      "name": "ConversionOverflow",
+      "msg": "Conversion Overflow"
     },
     {
-      "code": 6016,
-      "name": "DepositMintsZeroShares",
-      "msg": "Deposit would mint zero shares"
+      "code": 14019,
+      "name": "_Reserved8019",
+      "msg": "Reserved"
     },
     {
-      "code": 6017,
-      "name": "InsufficientAccruedApyBalance",
-      "msg": "Insufficient accrued APY balance"
+      "code": 14020,
+      "name": "InvalidArgument",
+      "msg": "Invalid argument"
     },
     {
-      "code": 6018,
-      "name": "InvalidRole",
-      "msg": "Invalid role configuration"
+      "code": 14021,
+      "name": "UserSanityCheck",
+      "msg": "User Sanity Check"
     },
     {
-      "code": 6019,
-      "name": "InvalidProtocolInteraction",
-      "msg": "Invalid protocol interaction CPI"
+      "code": 14022,
+      "name": "MathOverflow",
+      "msg": "Math overflow"
     },
     {
-      "code": 6020,
-      "name": "_Reserved7020",
-      "msg": "Reserved"
+      "code": 14023,
+      "name": "InvalidMarginFiAccount",
+      "msg": "Invalid MarginFi account - must be correct PDA for this vault"
     },
     {
-      "code": 6021,
-      "name": "InvalidExternalLiquidity",
-      "msg": "Invalid external liquidity configuration"
+      "code": 14024,
+      "name": "InvalidStartMarker",
+      "msg": "Invalid start marker"
     },
     {
-      "code": 6022,
-      "name": "SwapBalanceUnchanged",
-      "msg": "Swap did not change both source and destination balances"
+      "code": 14025,
+      "name": "OracleUpdateOnEmptyReserve",
+      "msg": "Unable to push oracle update on an empty vault reserve"
     },
     {
-      "code": 6023,
-      "name": "ProtocolBalanceUnchanged",
-      "msg": "Protocol interaction did not change the affected token balance"
+      "code": 14026,
+      "name": "InvalidRemainingAccountsLength",
+      "msg": "Invalid remaining accounts length"
     },
     {
-      "code": 6024,
-      "name": "ExcessiveSwapSlippage",
-      "msg": "Swap TVL loss exceeds the allowed slippage"
+      "code": 14027,
+      "name": "WithdrawalExceedsBalance",
+      "msg": "Specified withdrawal exceeds available balance"
     },
     {
-      "code": 6025,
-      "name": "TranchingNotEnabled",
-      "msg": "Vault tranching is not enabled"
+      "code": 14028,
+      "name": "InsufficientPendingYield",
+      "msg": "Insufficient pending yield"
     },
     {
-      "code": 6026,
-      "name": "TranchingAlreadyEnabled",
-      "msg": "Vault tranching is already enabled"
+      "code": 14029,
+      "name": "NotSupported",
+      "msg": "Not supported"
     },
     {
-      "code": 6027,
-      "name": "TrancheStateRequired",
-      "msg": "Tranche state account is required"
+      "code": 14030,
+      "name": "ExceedsMaxYieldingTvl",
+      "msg": "Exceeds maximum yielding TVL"
     },
     {
-      "code": 6028,
-      "name": "InvalidTrancheConfig",
-      "msg": "Invalid tranche configuration"
+      "code": 14031,
+      "name": "TranchingNotEnabled",
+      "msg": "Tranching is not enabled for this bank"
     },
     {
-      "code": 6029,
-      "name": "InvalidTrancheMint",
-      "msg": "Invalid tranche mint"
+      "code": 14032,
+      "name": "InvalidLeverageFactor",
+      "msg": "Invalid leverage factor - must be at least 10000 (1x)"
     },
     {
-      "code": 6030,
-      "name": "LossesDisabled",
-      "msg": "Vault losses are not enabled"
+      "code": 14033,
+      "name": "InsufficientStakedAmount",
+      "msg": "Insufficient staked amount"
     },
     {
-      "code": 6031,
+      "code": 14034,
+      "name": "JuniorTrancheEmpty",
+      "msg": "Junior tranche has no value"
+    },
+    {
+      "code": 14035,
+      "name": "InvalidTrancheConfig",
+      "msg": "Invalid tranche config parameter"
+    },
+    {
+      "code": 14036,
       "name": "WithdrawalQueueNotExpired",
-      "msg": "Withdrawal queue is not yet expired"
+      "msg": "Withdrawal queue lockup period has not expired"
     },
     {
-      "code": 6032,
+      "code": 14037,
       "name": "InvalidWithdrawalQueue",
-      "msg": "Invalid withdrawal queue"
+      "msg": "Withdrawal queue entry is not in a valid state"
     },
     {
-      "code": 6033,
-      "name": "AssetPriceNotSet",
-      "msg": "Destination asset has no price set; a consensus oracle price is required before swapping"
+      "code": 14038,
+      "name": "InvalidAccount",
+      "msg": "Account does not belong to the expected parent"
     },
     {
-      "code": 6034,
-      "name": "AssetHoldingNotEmpty",
-      "msg": "Asset holding still has a balance and cannot be removed"
+      "code": 14039,
+      "name": "MissingAccount",
+      "msg": "Required optional account is missing"
     },
     {
-      "code": 6035,
-      "name": "CannotRemoveBaseHolding",
-      "msg": "The base asset holding cannot be removed"
+      "code": 14040,
+      "name": "TrancheWipedOut",
+      "msg": "Junior tranche is wiped out and cannot accept new stakes"
     },
     {
-      "code": 6036,
-      "name": "UnauthorizedPriceUpdater",
-      "msg": "Caller is not authorized to trigger an asset price update"
+      "code": 14041,
+      "name": "VaultLossNotAccepted",
+      "msg": "Vault does not accept losses \u2014 enable losses_accepted before retrying"
     },
     {
-      "code": 6037,
-      "name": "InvalidStalenessConfig",
-      "msg": "Invalid asset-price staleness threshold"
+      "code": 14042,
+      "name": "CapitalLossExceedsReserve",
+      "msg": "Capital loss exceeds available yielding reserve"
     },
     {
-      "code": 6038,
-      "name": "AssetRebalanceRateLimitExceeded",
-      "msg": "Asset was rebalanced too recently"
+      "code": 14043,
+      "name": "RollingWithdrawalLimitExceeded",
+      "msg": "Rolling withdrawal limit exceeded"
     },
     {
-      "code": 6039,
-      "name": "InvalidShareTokenProgram",
-      "msg": "Share token program does not match the vault/tranche mint configuration"
+      "code": 14044,
+      "name": "VaultAlreadyMigrated",
+      "msg": "Legacy vault has already been migrated"
     },
     {
-      "code": 6040,
-      "name": "UnauthorizedVaultCreator",
-      "msg": "Caller is not on the vault-creator whitelist"
+      "code": 14045,
+      "name": "InvalidMigrationState",
+      "msg": "Legacy vault migration is incomplete or invalid"
     },
     {
-      "code": 6041,
-      "name": "InvalidShareMintDecimals",
-      "msg": "Share mint decimals must match the deposit asset mint decimals"
+      "code": 14046,
+      "name": "InvalidMigrationMintAuthority",
+      "msg": "Mint authority does not match the expected migration source"
     },
     {
-      "code": 6042,
-      "name": "InvalidFeeExemption",
-      "msg": "Invalid fee-exemption PDA signer or seeds"
+      "code": 14047,
+      "name": "BankMigrationIncomplete",
+      "msg": "Legacy bank or tranche migration is incomplete \u2014 source accounting and escrow must be fully drained before mint authority transfer"
     }
   ],
   "types": [
@@ -13622,6 +13651,13 @@ var IDL = {
             "name": "target_lockup_duration_secs",
             "type": "i64"
           },
+          {
+            "name": "junior_deposit_cap",
+            "docs": [
+              "Maximum junior tranche value in accounting units. Zero means uncapped."
+            ],
+            "type": "u64"
+          },
           {
             "name": "for_migration",
             "docs": [
@@ -14419,12 +14455,21 @@ var IDL = {
             "name": "target_lockup_duration_secs",
             "type": "i64"
           },
+          {
+            "name": "junior_deposit_cap",
+            "docs": [
+              "Maximum junior tranche value in vault accounting units. Zero disables",
+              "the cap. Yield may carry the tranche above this value, but further",
+              "junior deposits remain blocked until its value falls below the cap."
+            ],
+            "type": "u64"
+          },
           {
             "name": "_padding2",
             "type": {
               "array": [
                 "u64",
-                14
+                13
               ]
             }
           }
@@ -14542,6 +14587,15 @@ var IDL = {
             "type": {
               "option": "i64"
             }
+          },
+          {
+            "name": "junior_deposit_cap",
+            "docs": [
+              "Maximum junior tranche value in accounting units. Zero means uncapped."
+            ],
+            "type": {
+              "option": "u64"
+            }
           }
         ]
       }
@@ -15931,6 +15985,7 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
       earlyUnstakeFeeBps: args.earlyUnstakeFeeBps,
       standardUnstakeFeeBps: args.standardUnstakeFeeBps,
       targetLockupDurationSecs: args.targetLockupDurationSecs,
+      juniorDepositCap: args.juniorDepositCap,
       forMigration: args.forMigration
     }).accountsPartial({
       curator: (0, import_common8.toWeb3Pk)(args.curator),
@@ -15975,6 +16030,7 @@ var CreateTrancheStateBuilder = class extends VaultBuilderBase {
       targetLockupDurationSecs: new import_core.BN(
         (txArgs.targetLockupDurationSecs ?? DEFAULT_JUNIOR_WITHDRAWAL_LOCKUP_SECS).toString()
       ),
+      juniorDepositCap: new import_core.BN((txArgs.juniorDepositCap ?? 0n).toString()),
       forMigration,
       tokenProgram: txArgs.tokenProgram ?? TOKEN_PROGRAM_ID
     };
@@ -17608,7 +17664,8 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
       seniorFixedApyBps: args.seniorFixedApyBps,
       earlyUnstakeFeeBps: args.earlyUnstakeFeeBps,
       standardUnstakeFeeBps: args.standardUnstakeFeeBps,
-      targetLockupDurationSecs: args.targetLockupDurationSecs
+      targetLockupDurationSecs: args.targetLockupDurationSecs,
+      juniorDepositCap: args.juniorDepositCap
     }).accountsPartial({
       curator: (0, import_common29.toWeb3Pk)(args.curator),
       vault: (0, import_common29.toWeb3Pk)(args.vault),
@@ -17629,7 +17686,8 @@ var UpdateTrancheConfigBuilder = class extends VaultBuilderBase {
       seniorFixedApyBps: txArgs.seniorFixedApyBps ?? null,
       earlyUnstakeFeeBps: txArgs.earlyUnstakeFeeBps ?? null,
       standardUnstakeFeeBps: txArgs.standardUnstakeFeeBps ?? null,
-      targetLockupDurationSecs: txArgs.targetLockupDurationSecs === void 0 ? null : new import_core11.BN(txArgs.targetLockupDurationSecs.toString())
+      targetLockupDurationSecs: txArgs.targetLockupDurationSecs === void 0 ? null : new import_core11.BN(txArgs.targetLockupDurationSecs.toString()),
+      juniorDepositCap: txArgs.juniorDepositCap === void 0 ? null : new import_core11.BN(txArgs.juniorDepositCap.toString())
     };
   }
   async buildPlanExtras(args) {
@@ -18120,7 +18178,7 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
   }
   async buildPreambleInstructions(args) {
     const payer = (0, import_common34.toWeb3Pk)(args.manager);
-    const instructions = [
+    const instructions2 = [
       (0, import_spl_token17.createAssociatedTokenAccountIdempotentInstruction)(
         payer,
         (0, import_common34.toWeb3Pk)(args.allocationMintAta),
@@ -18155,7 +18213,7 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
       )
     ];
     if (args.sourceVault && args.sourceShareMint && args.sourceVaultMintAta && args.allocationSourceShareAta) {
-      instructions.push(
+      instructions2.push(
         (0, import_spl_token17.createAssociatedTokenAccountIdempotentInstruction)(
           payer,
           (0, import_common34.toWeb3Pk)(args.sourceVaultMintAta),
@@ -18174,7 +18232,7 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
         )
       );
     }
-    return instructions.map(import_common34.toKitInstruction);
+    return instructions2.map(import_common34.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -18409,15 +18467,129 @@ function makeProvider(connection, payer) {
   });
 }
 
+// src/utils/squads.ts
+var squads = __toESM(require("@sqds/multisig"));
+var import_web321 = require("@solana/web3.js");
+function validateVaultIndex(vaultIndex) {
+  if (!Number.isSafeInteger(vaultIndex) || vaultIndex < 0) {
+    throw new Error("Squads vaultIndex must be a non-negative safe integer");
+  }
+}
+function resolveSquadsWalletRoute(route) {
+  validateVaultIndex(route.vaultIndex);
+  const wallet = new import_web321.PublicKey(route.wallet);
+  const multisigPda = new import_web321.PublicKey(route.multisigPda);
+  const [vaultPda] = squads.getVaultPda({
+    multisigPda,
+    index: route.vaultIndex
+  });
+  return { ...route, wallet, multisigPda, vaultPda };
+}
+function findSquadsWalletRoute(wallet, routes) {
+  const walletKey = typeof wallet === "string" ? new import_web321.PublicKey(wallet) : wallet;
+  const route = routes.find(
+    (candidate) => candidate.wallet === walletKey.toBase58()
+  );
+  return route ? resolveSquadsWalletRoute(route) : void 0;
+}
+function validateSquadsWalletRoutes(routes) {
+  const wallets = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const resolved = resolveSquadsWalletRoute(route);
+    const wallet = resolved.wallet.toBase58();
+    if (wallets.has(wallet)) {
+      throw new Error(`Duplicate Squads route for wallet ${wallet}`);
+    }
+    wallets.add(wallet);
+  }
+}
+function vaultAuthorityForWallet(wallet, routes) {
+  const walletKey = typeof wallet === "string" ? new import_web321.PublicKey(wallet) : wallet;
+  return findSquadsWalletRoute(walletKey, routes)?.vaultPda ?? walletKey;
+}
+async function prepareVaultTransaction(args) {
+  const { connection, proposer, instructions: instructions2 } = args;
+  const route = findSquadsWalletRoute(proposer, args.squadsRoutes ?? []);
+  if (!route) {
+    return {
+      kind: "direct",
+      transaction: new import_web321.Transaction().add(...instructions2),
+      authority: proposer
+    };
+  }
+  const multisig = await squads.accounts.Multisig.fromAccountAddress(
+    connection,
+    route.multisigPda
+  );
+  const member = multisig.members.find(
+    (candidate) => candidate.key.equals(proposer)
+  );
+  if (!member) {
+    throw new Error(
+      `Wallet ${proposer.toBase58()} is not a member of Squads multisig ${route.multisigPda.toBase58()}`
+    );
+  }
+  if (!squads.types.Permissions.has(
+    member.permissions,
+    squads.types.Permission.Initiate
+  )) {
+    throw new Error(
+      `Wallet ${proposer.toBase58()} cannot initiate proposals for Squads multisig ${route.multisigPda.toBase58()}`
+    );
+  }
+  const transactionIndex = BigInt(multisig.transactionIndex.toString()) + 1n;
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const transactionMessage = new import_web321.TransactionMessage({
+    payerKey: route.vaultPda,
+    recentBlockhash: blockhash,
+    instructions: [...instructions2]
+  });
+  const createVaultTransactionIx = squads.instructions.vaultTransactionCreate({
+    multisigPda: route.multisigPda,
+    transactionIndex,
+    creator: proposer,
+    vaultIndex: route.vaultIndex,
+    ephemeralSigners: 0,
+    transactionMessage,
+    memo: route.memo
+  });
+  const createProposalIx = squads.instructions.proposalCreate({
+    multisigPda: route.multisigPda,
+    transactionIndex,
+    creator: proposer
+  });
+  const [proposalPda] = squads.getProposalPda({
+    multisigPda: route.multisigPda,
+    transactionIndex
+  });
+  const [vaultTransactionPda] = squads.getTransactionPda({
+    multisigPda: route.multisigPda,
+    index: transactionIndex
+  });
+  return {
+    kind: "squads",
+    transaction: new import_web321.Transaction().add(
+      createVaultTransactionIx,
+      createProposalIx
+    ),
+    authority: route.vaultPda,
+    multisigPda: route.multisigPda,
+    vaultIndex: route.vaultIndex,
+    transactionIndex,
+    proposalPda,
+    vaultTransactionPda
+  };
+}
+
 // src/utils/token.ts
 var import_spl_token18 = require("@solana/spl-token");
-var import_web321 = require("@solana/web3.js");
+var import_web322 = require("@solana/web3.js");
 var import_common37 = __toESM(require_dist());
 async function createTokenMintIxs(connection, payer, authority, decimals, tokenProgram = import_spl_token18.TOKEN_2022_PROGRAM_ID) {
-  const mint = import_web321.Keypair.generate();
+  const mint = import_web322.Keypair.generate();
   const lamports = await (0, import_spl_token18.getMinimumBalanceForRentExemptMint)(connection);
   const ixs = [
-    import_web321.SystemProgram.createAccount({
+    import_web322.SystemProgram.createAccount({
       fromPubkey: payer,
       newAccountPubkey: mint.publicKey,
       space: import_spl_token18.MINT_SIZE,
@@ -18443,7 +18615,7 @@ async function createTokenMint(connection, payer, decimals, tokenProgram = impor
     tokenProgram
   );
   const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
-  const tx = new import_web321.Transaction().add(...ixs);
+  const tx = new import_web322.Transaction().add(...ixs);
   tx.feePayer = payer.publicKey;
   tx.recentBlockhash = blockhash;
   tx.sign(payer, mint);
@@ -18482,7 +18654,7 @@ async function mintTokensTo(connection, payer, mint, destination, amount, tokenP
       tokenProgramPk
     )
   ];
-  const tx = new import_web321.Transaction().add(...ixs);
+  const tx = new import_web322.Transaction().add(...ixs);
   await connection.sendTransaction(tx, [payer]);
 }
 
@@ -18677,6 +18849,40 @@ async function getBalance(accountName, atTime) {
     "GET"
   )).data;
 }
+async function createYieldPayment(params) {
+  return unwrapData(
+    await yieldApiReq(
+      accountEndpoint(params.accountName, "yield-payments"),
+      "POST",
+      {
+        amount: params.amount,
+        effective_at: dateToStr(params.effectiveAt),
+        idempotency_key: params.idempotencyKey,
+        password: params.password
+      }
+    )
+  );
+}
+async function confirmYieldPayment(params) {
+  return unwrapData(
+    await yieldApiReq(
+      accountEndpoint(
+        params.accountName,
+        `yield-payments/${encodeURIComponent(params.paymentId)}/confirm`
+      ),
+      "POST",
+      {
+        transaction_signature: params.transactionSignature,
+        password: params.password
+      }
+    )
+  );
+}
+async function getYieldPayments(accountName) {
+  return unwrapData(
+    await yieldApiReq(accountEndpoint(accountName, "yield-payments"), "GET")
+  );
+}
 async function getYield(accountName, start, end) {
   return (await yieldApiReq(
     accountEndpoint(accountName, "yield") + (start ? `?start=${dateToStr(start)}` : "") + (start && end ? `&end=${dateToStr(end)}` : end ? `?end=${dateToStr(end)}` : ""),
@@ -18692,6 +18898,14 @@ async function getTotalYield(accountNames, start, end) {
   }
   return totalYield;
 }
+async function getTotalOutstandingYield(accountNames, start, end) {
+  let total = 0;
+  for (const accountName of accountNames) {
+    const response = await getYield(accountName, start, end);
+    total += response.outstanding_yield;
+  }
+  return total;
+}
 
 // src/services/withdrawalQueueService.ts
 var import_common38 = __toESM(require_dist());
@@ -18713,8 +18927,8 @@ var WithdrawalQueueService = class {
   /** All withdrawal-queue accounts owned by the vault program. */
   async fetchAllQueues() {
     const program = this.client.program.account;
-    const accounts = await program.vaultWithdrawalQueue.all();
-    return accounts.map(
+    const accounts2 = await program.vaultWithdrawalQueue.all();
+    return accounts2.map(
       (entry) => this.toSnapshot((0, import_common38.fromWeb3Pk)(entry.publicKey), entry.account)
     );
   }
@@ -19074,7 +19288,7 @@ var JupiterPriceSource = class {
 };
 
 // src/services/consensusOracle/jupiterBalanceSource.ts
-var import_web322 = require("@solana/web3.js");
+var import_web323 = require("@solana/web3.js");
 var import_spl_token19 = require("@solana/spl-token");
 var import_common40 = __toESM(require_dist());
 var DEFAULT_BASE_URL2 = "https://lite-api.jup.ag/ultra/v1/balances";
@@ -19131,7 +19345,7 @@ var JupiterBalanceSource = class {
     for (const programId of [import_spl_token19.TOKEN_PROGRAM_ID, import_spl_token19.TOKEN_2022_PROGRAM_ID]) {
       const { value } = await this.connection.getParsedTokenAccountsByOwner(
         ownerPk,
-        { programId: new import_web322.PublicKey(programId) }
+        { programId: new import_web323.PublicKey(programId) }
       );
       for (const { account } of value) {
         const info = account.data.parsed?.info;
@@ -19182,7 +19396,7 @@ var StaticPositionProvider = class {
 
 // src/services/consensusOracle/kaminoPositionProvider.ts
 var import_kit12 = require("@solana/kit");
-var import_web323 = require("@solana/web3.js");
+var import_web324 = require("@solana/web3.js");
 var import_klend_sdk = require("@kamino-finance/klend-sdk");
 async function readKaminoBalance(manager, vault, sharesHolder) {
   const userShares = await manager.getUserSharesBalanceSingleVault(
@@ -19219,7 +19433,7 @@ var KaminoPositionProvider = class {
       const amount = await readKaminoBalance(
         manager,
         kVault,
-        new import_web323.PublicKey(sharesHolder)
+        new import_web324.PublicKey(sharesHolder)
       );
       out.push({ mint: ref.mint, amount });
     }
@@ -19228,7 +19442,7 @@ var KaminoPositionProvider = class {
 };
 
 // src/services/consensusOracle/marginfiPositionProvider.ts
-var import_web324 = require("@solana/web3.js");
+var import_web325 = require("@solana/web3.js");
 var import_marginfi_client_v2 = require("@mrgnlabs/marginfi-client-v2");
 function parseBankPksFromMarginfiAccount(data) {
   const DISCRIMINATOR = 8;
@@ -19241,7 +19455,7 @@ function parseBankPksFromMarginfiAccount(data) {
     if (base + BALANCE_SIZE > data.length) break;
     const active = data[base];
     if (!active) continue;
-    out.push(new import_web324.PublicKey(data.subarray(base + 1, base + 33)));
+    out.push(new import_web325.PublicKey(data.subarray(base + 1, base + 33)));
   }
   return out;
 }
@@ -19279,8 +19493,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_web324.PublicKey(bank));
-    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web324.PublicKey(account));
+    const explicitBanks = refs.map((r) => r.marginfiBank).filter(Boolean).map((bank) => new import_web325.PublicKey(bank));
+    const autoAccountPks = refs.filter((r) => !r.marginfiBank).map((r) => r.marginfiAccount).filter(Boolean).map((account) => new import_web325.PublicKey(account));
     const autoBanks = [];
     for (const accountPk of autoAccountPks) {
       try {
@@ -19311,14 +19525,14 @@ var MarginfiPositionProvider = class {
       if (bank) {
         const amount = await readMarginfiBalance(
           client,
-          new import_web324.PublicKey(account),
-          new import_web324.PublicKey(bank)
+          new import_web325.PublicKey(account),
+          new import_web325.PublicKey(bank)
         );
         out.push({ mint: ref.mint, amount });
       } else {
         const balances = await readAllMarginfiBalances(
           client,
-          new import_web324.PublicKey(account)
+          new import_web325.PublicKey(account)
         );
         for (const { mint, amount } of balances) {
           out.push({ mint: mint.toBase58(), amount });
@@ -19338,7 +19552,11 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
     balanceSource: new JupiterBalanceSource(connection, {
       rpcOnly: opts.rpcOnly ?? false,
       log
-    })
+    }),
+    yieldTracker: {
+      getTotalOutstandingYield,
+      getYieldPayments
+    }
   };
   if (opts.includeExternalPositions ?? true) {
     deps.externalPositions = new ExternalPositionRegistry(
@@ -19353,7 +19571,7 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
 }
 
 // src/services/consensusOracle/consensusOracleService.ts
-var import_web325 = require("@solana/web3.js");
+var import_web326 = require("@solana/web3.js");
 var import_common41 = __toESM(require_dist());
 var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
 var CONSENSUS_ORACLE_VARIANT = "consensusoracle";
@@ -19387,7 +19605,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_web326.PublicKey(pubkeyBytes).toBase58();
     refs.push({
       kind: "marginfi",
       mint: "",
@@ -19417,6 +19635,7 @@ var ConsensusOracleService = class {
       log(`vault ${target.vault}: no consensus holdings, skipping`);
       return { vault: target.vault, updates: [], dryRun };
     }
+    await this.assertNoUnconfirmedYieldPayments(target);
     const inputs = await this.gatherPricingInputs(
       target,
       vaultState,
@@ -19427,7 +19646,7 @@ var ConsensusOracleService = class {
       log(`vault ${target.vault}: dry run, ${updates.length} holding(s)`);
       return { vault: target.vault, updates, dryRun: true };
     }
-    const { updateSignature, crankSignature, crankSkippedReason } = await this.settleVault(signer, target.vault, updates, vaultState, log);
+    const { updateSignature, crankSignature, crankSkippedReason } = await this.settleVault(signer, target, updates, vaultState, log);
     return {
       vault: target.vault,
       updates,
@@ -19437,6 +19656,39 @@ var ConsensusOracleService = class {
       crankSkippedReason
     };
   }
+  /**
+   * Fail closed while any configured yield account has an unsettled payment.
+   * The payout must be confirmed only after it is visible in the same wallet
+   * balance source used by this service. Until then, no oracle update is safe.
+   */
+  async assertNoUnconfirmedYieldPayments(target) {
+    const accountNames = [
+      ...new Set(
+        (target.holdings ?? []).flatMap(
+          (holding) => holding.yieldAccountNames ?? []
+        )
+      )
+    ];
+    if (accountNames.length === 0) return;
+    if (!this.deps.yieldTracker) {
+      throw new Error(
+        `vault ${target.vault}: yield accounts are configured but no yield tracker is available`
+      );
+    }
+    for (const accountName of accountNames) {
+      const payments = await this.deps.yieldTracker.getYieldPayments(
+        accountName
+      );
+      const unconfirmed = payments.filter(
+        (payment) => payment.status !== "confirmed"
+      );
+      if (unconfirmed.length > 0) {
+        throw new Error(
+          `vault ${target.vault}: oracle update blocked because yield account "${accountName}" has ${unconfirmed.length} unconfirmed payment(s): ` + unconfirmed.map((payment) => payment.id).join(", ")
+        );
+      }
+    }
+  }
   /**
    * Drive several vaults in sequence. Non-fatal: a failure on one vault is
    * recorded and the rest still run (mirrors the oracle-updater daemon).
@@ -19588,7 +19840,7 @@ var ConsensusOracleService = class {
   /** Accrued yield (base units) attributed to a holding via its configured accounts. */
   async resolveYieldAmount(cfg, decimals) {
     if (!this.deps.yieldTracker || !cfg?.yieldAccountNames?.length) return 0n;
-    const totalYieldUi = await this.deps.yieldTracker.getTotalYield(
+    const totalYieldUi = await this.deps.yieldTracker.getTotalOutstandingYield(
       cfg.yieldAccountNames
     );
     return totalYieldUi > 0 ? (0, import_common41.fromUiAmount)(totalYieldUi, decimals) : 0n;
@@ -19634,7 +19886,8 @@ var ConsensusOracleService = class {
   }
   // ── Settlement ───────────────────────────────────────────────────────────────
   /** Push the consensus report for all holdings, then settle NAV. */
-  async settleVault(signer, vault, updates, vaultState, log) {
+  async settleVault(signer, target, updates, vaultState, log) {
+    const vault = target.vault;
     log(
       `vault ${vault}: submitting ${updates.length} consensus asset update(s)`
     );
@@ -19644,6 +19897,7 @@ var ConsensusOracleService = class {
       );
     }
     await this.logProspectiveApy(vault, updates, vaultState, log);
+    await this.assertNoUnconfirmedYieldPayments(target);
     const updateSignature = await this.oracle.updateAssetConsensusPrice(
       signer,
       {
@@ -19766,7 +20020,8 @@ var MockYieldTracker = class {
         aprBps: cfg.aprBps,
         initialPrincipal: cfg.principal ?? 0,
         startTs: cfg.startTs ?? this.clock.now(),
-        cashflows: []
+        cashflows: [],
+        yieldPayments: []
       });
     }
   }
@@ -19776,7 +20031,8 @@ var MockYieldTracker = class {
       aprBps: cfg.aprBps,
       initialPrincipal: cfg.principal ?? 0,
       startTs: cfg.startTs ?? this.clock.now(),
-      cashflows: []
+      cashflows: [],
+      yieldPayments: []
     });
   }
   require(name) {
@@ -19786,6 +20042,12 @@ var MockYieldTracker = class {
     }
     return state;
   }
+  async getYieldPayments(accountName) {
+    return this.require(accountName).yieldPayments.map((payment) => ({
+      id: payment.paymentId,
+      status: payment.status
+    }));
+  }
   async getYield(accountName, start, end) {
     const state = this.require(accountName);
     const windowStartMs = Math.max(
@@ -19809,9 +20071,16 @@ var MockYieldTracker = class {
     }
     const tailSecs = Math.max(0, (windowEndMs - segStart) / 1e3);
     totalYield += principal * apr * (tailSecs / SECONDS_PER_YEAR);
+    const paidYield = state.yieldPayments.reduce((sum, payment) => {
+      return payment.status === "confirmed" && payment.effectiveAt > windowStartMs && payment.effectiveAt <= windowEndMs ? sum + payment.amount : sum;
+    }, 0);
+    const outstandingYield = Math.max(0, totalYield - paidYield);
     return {
       account: accountName,
       totalYield,
+      grossYield: totalYield,
+      paidYield,
+      outstandingYield,
       principalAtEnd: principal,
       aprUsed: apr,
       accrualStart: new Date(windowStartMs),
@@ -19826,9 +20095,17 @@ var MockYieldTracker = class {
     }
     return total;
   }
+  async getTotalOutstandingYield(accountNames, start, end) {
+    let total = 0;
+    for (const name of accountNames) {
+      const snapshot = await this.getYield(name, start, end);
+      total += snapshot.outstandingYield;
+    }
+    return total;
+  }
   async getBalance(accountName, atTime) {
     const snapshot = await this.getYield(accountName, void 0, atTime);
-    return snapshot.principalAtEnd + snapshot.totalYield;
+    return snapshot.principalAtEnd + snapshot.outstandingYield;
   }
   async addCashflow(params) {
     const state = this.require(params.accountName);
@@ -19838,11 +20115,65 @@ var MockYieldTracker = class {
       amount: signed
     });
   }
+  async createYieldPayment(params) {
+    const state = this.require(params.accountName);
+    if (!(params.amount > 0)) throw new Error("Yield payment must be positive");
+    const existing = state.yieldPayments.find(
+      (payment) => payment.paymentId === params.paymentId
+    );
+    if (existing) {
+      if (existing.amount !== params.amount || existing.effectiveAt !== params.effectiveAt.getTime()) {
+        throw new Error(
+          `Yield payment "${params.paymentId}" already exists with different details`
+        );
+      }
+      return;
+    }
+    state.yieldPayments.push({
+      paymentId: params.paymentId,
+      amount: params.amount,
+      effectiveAt: params.effectiveAt.getTime(),
+      status: "pending"
+    });
+  }
+  async confirmYieldPayment(params) {
+    const state = this.require(params.accountName);
+    const payment = state.yieldPayments.find(
+      (candidate) => candidate.paymentId === params.paymentId
+    );
+    if (!payment)
+      throw new Error(`Unknown yield payment "${params.paymentId}"`);
+    if (payment.status === "confirmed") {
+      if (payment.transactionSignature !== params.transactionSignature) {
+        throw new Error(
+          "Yield payment already confirmed with another signature"
+        );
+      }
+      return;
+    }
+    const chronologicalPayments = state.yieldPayments.filter(
+      (candidate) => candidate.status === "confirmed" || candidate === payment
+    ).sort((a, b) => a.effectiveAt - b.effectiveAt);
+    let cumulativePaid = 0;
+    for (const candidate of chronologicalPayments) {
+      cumulativePaid += candidate.amount;
+      const snapshot = await this.getYield(
+        params.accountName,
+        void 0,
+        new Date(candidate.effectiveAt)
+      );
+      if (cumulativePaid > snapshot.totalYield + 1e-9) {
+        throw new Error("Confirmed payment exceeds accrued unpaid yield");
+      }
+    }
+    payment.status = "confirmed";
+    payment.transactionSignature = params.transactionSignature;
+  }
 };
 
 // src/services/externalLiquidityIntegrityService.ts
 var import_kit13 = require("@solana/kit");
-var import_web326 = require("@solana/web3.js");
+var import_web327 = require("@solana/web3.js");
 var import_common42 = __toESM(require_dist());
 var import_marginfi2 = __toESM(require_dist2());
 function parseActiveSlots(externalLiquidity) {
@@ -19855,7 +20186,7 @@ function parseActiveSlots(externalLiquidity) {
     if (discriminant === 0) continue;
     if (discriminant !== 1) continue;
     const pubkeyBytes = new Uint8Array(data.slice(8, 40));
-    const userAccount = (0, import_common42.toAddress)(new import_web326.PublicKey(pubkeyBytes));
+    const userAccount = (0, import_common42.toAddress)(new import_web327.PublicKey(pubkeyBytes));
     results.push({ index: i, source: "marginfi", userAccount });
   }
   return results;
@@ -19921,7 +20252,7 @@ var ExternalLiquidityIntegrityService = class {
       return result;
     }
     const hwManagerAddress = (0, import_common42.fromWeb3Pk)(hwManager.publicKey);
-    const vaultPk = new import_web326.PublicKey(vault.toString());
+    const vaultPk = new import_web327.PublicKey(vault.toString());
     const registeredHwManager = pubkeyStr(
       vaultState.roles.hwManager
     );
@@ -20111,33 +20442,42 @@ var ExternalLiquidityIntegrityService = class {
   WithdrawalQueueService,
   addCashflowUpdate,
   address,
+  confirmYieldPayment,
   createAccount,
   createLiveConsensusOracleDeps,
   createRpcFromConnection,
   createTokenMint,
   createTokenMintIxs,
   createVaultClient,
+  createYieldPayment,
   dateToStr,
   defaultKeypairPath,
   deleteAccount,
+  findSquadsWalletRoute,
   fromUiAmount,
   getAccounts,
   getBalance,
   getCashflows,
   getRpcUrl,
+  getTotalOutstandingYield,
   getTotalYield,
   getVaultProgramId,
   getYield,
+  getYieldPayments,
   isVaultEnv,
   keypairAddress,
   loadKeypair,
   makeProvider,
   mintTokensTo,
+  prepareVaultTransaction,
   resolveKeypairPath,
+  resolveSquadsWalletRoute,
   roundToNextUtcMidnight,
   runLiveConsensusOracle,
   systemClock,
   toUiAmount,
   updateAccount,
-  updateDynamicApr
+  updateDynamicApr,
+  validateSquadsWalletRoutes,
+  vaultAuthorityForWallet
 });