@perena/vault-sdk 1.0.20 → 1.0.24

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)
       }));
@@ -250,9 +250,9 @@ var require_meta = __commonJS({
     exports2.toCustomAccountMeta = toCustomAccountMeta;
     exports2.toCustomAccountMetaFromWeb3AccountMeta = toCustomAccountMetaFromWeb3AccountMeta;
     var roles_1 = require_roles();
-    function toCustomAccountMeta(address10, isWritable, requiredAtaDetails, isSigner) {
+    function toCustomAccountMeta(address12, isWritable, requiredAtaDetails, isSigner) {
       const role = (0, roles_1.getAccountRole)(isWritable ?? false, isSigner ?? false);
-      return { address: address10, role, isRequiredAta: requiredAtaDetails };
+      return { address: address12, role, isRequiredAta: requiredAtaDetails };
     }
     function toCustomAccountMetaFromWeb3AccountMeta(web3AccountMeta) {
       return toCustomAccountMeta(web3AccountMeta.pubkey.toBase58(), web3AccountMeta.isWritable, void 0, web3AccountMeta.isSigner);
@@ -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,29 +594,29 @@ 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({
+      const message2 = new web3_js_1.TransactionMessage({
         payerKey: payer.publicKey,
         recentBlockhash: blockhash,
-        instructions
+        instructions: instructions2
       }).compileToV0Message(lookupTableAccounts);
-      const tx = new web3_js_1.VersionedTransaction(message);
+      const tx = new web3_js_1.VersionedTransaction(message2);
       tx.sign([payer]);
       const signature = await connection.sendRawTransaction(tx.serialize(), {
         skipPreflight: true
@@ -1200,8 +1200,8 @@ var require_cpiClient = __commonJS({
     var kit_1 = require("@solana/kit");
     var common_1 = require_dist();
     var constants_1 = require_constants3();
-    function account(address10, role) {
-      return { address: address10, role };
+    function account(address12, role) {
+      return { address: address12, role };
     }
     function requiredAddress(value, label) {
       if (!value) {
@@ -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,20 +1283,20 @@ 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
         });
         const bankAndOracleRemainingAccounts = [
           account(this.accounts.bank, kit_1.AccountRole.READONLY),
-          ...this.accounts.oracleAccounts.map((address10) => account(address10, kit_1.AccountRole.READONLY))
+          ...this.accounts.oracleAccounts.map((address12) => account(address12, kit_1.AccountRole.READONLY))
         ];
         return {
           cpiType: params.cpiType ?? common_1.CpiTypes.MARGINFI_WITHDRAW,
           programId: this.programId,
           accounts: [
-            ...orderedWithdrawAccounts(accounts),
+            ...orderedWithdrawAccounts(accounts2),
             ...params.remainingAccounts ?? [],
             ...bankAndOracleRemainingAccounts
           ],
@@ -1414,11 +1414,17 @@ __export(index_exports, {
   JupiterPriceSource: () => JupiterPriceSource,
   JupiterSwapBuilder: () => JupiterSwapBuilder,
   KaminoPositionProvider: () => KaminoPositionProvider,
+  LOCAL_PROTOCOL_ADMIN: () => LOCAL_PROTOCOL_ADMIN,
+  LivePriceSource: () => LivePriceSource,
   MAX_PRICE_STALENESS_THRESHOLD_SECS: () => MAX_PRICE_STALENESS_THRESHOLD_SECS,
   ManagerRedepositAssetBuilder: () => ManagerRedepositAssetBuilder,
   ManagerWithdrawAssetBuilder: () => ManagerWithdrawAssetBuilder,
   MarginfiPositionProvider: () => MarginfiPositionProvider,
   MockYieldTracker: () => MockYieldTracker,
+  NEST_API_BASE_URL: () => NEST_API_BASE_URL,
+  NEST_RWA_SHARE_MINT: () => NEST_RWA_SHARE_MINT,
+  NEST_VAULT_SLUG: () => NEST_VAULT_SLUG,
+  NestPriceSource: () => NestPriceSource,
   OracleService: () => OracleService,
   PROGRAM_FEE_EXEMPT_OWNER_WHITELIST: () => PROGRAM_FEE_EXEMPT_OWNER_WHITELIST,
   PROTOCOL_ADMIN: () => PROTOCOL_ADMIN,
@@ -1461,6 +1467,7 @@ __export(index_exports, {
   WithdrawalQueueService: () => WithdrawalQueueService,
   addCashflowUpdate: () => addCashflowUpdate,
   address: () => import_kit10.address,
+  applyEffectiveApy: () => applyEffectiveApy,
   confirmYieldPayment: () => confirmYieldPayment,
   createAccount: () => createAccount,
   createLiveConsensusOracleDeps: () => createLiveConsensusOracleDeps,
@@ -1472,6 +1479,9 @@ __export(index_exports, {
   dateToStr: () => dateToStr,
   defaultKeypairPath: () => defaultKeypairPath,
   deleteAccount: () => deleteAccount,
+  fetchNestTokenPrice: () => fetchNestTokenPrice,
+  findSquadsWalletRoute: () => findSquadsWalletRoute,
+  formatSettlementSimulation: () => formatSettlementSimulation,
   fromUiAmount: () => fromUiAmount,
   getAccounts: () => getAccounts,
   getBalance: () => getBalance,
@@ -1487,13 +1497,18 @@ __export(index_exports, {
   loadKeypair: () => loadKeypair,
   makeProvider: () => makeProvider,
   mintTokensTo: () => mintTokensTo,
+  prepareVaultTransaction: () => prepareVaultTransaction,
   resolveKeypairPath: () => resolveKeypairPath,
+  resolveSquadsWalletRoute: () => resolveSquadsWalletRoute,
   roundToNextUtcMidnight: () => roundToNextUtcMidnight,
   runLiveConsensusOracle: () => runLiveConsensusOracle,
+  simulateConsensusOracleSettlement: () => simulateConsensusOracleSettlement,
   systemClock: () => systemClock,
   toUiAmount: () => toUiAmount,
   updateAccount: () => updateAccount,
-  updateDynamicApr: () => updateDynamicApr
+  updateDynamicApr: () => updateDynamicApr,
+  validateSquadsWalletRoutes: () => validateSquadsWalletRoutes,
+  vaultAuthorityForWallet: () => vaultAuthorityForWallet
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1506,6 +1521,9 @@ var VAULT_PROGRAM_ID = (0, import_kit.address)(
 );
 var VAULT_PROGRAM_PUBLIC_KEY = new import_web3.PublicKey(VAULT_PROGRAM_ID);
 var PROTOCOL_ADMIN = (0, import_kit.address)(
+  "4jMRBkpWrfhhwFYTwG3o7hmsXQwbJUwdyUX8htB6KwLJ"
+);
+var LOCAL_PROTOCOL_ADMIN = (0, import_kit.address)(
   "BQJZAhDnvgSGHjdAbzQEXRBYzSBuWgSYqDzhDnUSRWGR"
 );
 var PROTOCOL_FEE_RECIPIENT = (0, import_kit.address)(
@@ -1517,7 +1535,7 @@ var PROGRAM_FEE_EXEMPT_OWNER_WHITELIST = [
   (0, import_kit.address)("LYC8YiiSzQfPpxUW2tpxfuPKGZwywAJhXKUfDP2B66f")
 ];
 var VAULT_CREATOR_WHITELIST = [
-  (0, import_kit.address)("11111111111111111111111111111111")
+  (0, import_kit.address)("4jMRBkpWrfhhwFYTwG3o7hmsXQwbJUwdyUX8htB6KwLJ")
 ];
 var TOKEN_PROGRAM_ID = (0, import_kit.address)(
   import_spl_token.TOKEN_2022_PROGRAM_ID.toBase58()
@@ -1763,8 +1781,7 @@ var IDL = {
         {
           "name": "fee_asset_mint",
           "docs": [
-            "Base-asset mint used to pay performance fees on settlement. Must match",
-            "an `is_base` holding; choose a mint whose vault ATA has liquidity."
+            "Legacy fee-asset account retained in this instruction's account schema."
           ]
         },
         {
@@ -1827,7 +1844,7 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting for accrued fees."
+            "Legacy fee-vault account retained in this instruction's account schema."
           ],
           "writable": true
         },
@@ -1921,84 +1938,18 @@ var IDL = {
           "signer": true
         },
         {
-          "name": "vault"
-        },
-        {
-          "name": "fee_asset_mint",
-          "docs": [
-            "Vault base asset whose fee-vault ATA should be swept. Must match an",
-            "`is_base` holding with a fresh price."
-          ]
-        },
-        {
-          "name": "fee_vault",
-          "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting for accrued fees."
-          ],
+          "name": "vault",
           "writable": true
         },
         {
-          "name": "fee_vault_ata",
-          "writable": true,
-          "pda": {
-            "seeds": [
-              {
-                "kind": "account",
-                "path": "fee_vault"
-              },
-              {
-                "kind": "account",
-                "path": "fee_asset_token_program"
-              },
-              {
-                "kind": "account",
-                "path": "fee_asset_mint"
-              }
-            ],
-            "program": {
-              "kind": "const",
-              "value": [
-                140,
-                151,
-                37,
-                143,
-                78,
-                36,
-                137,
-                241,
-                187,
-                61,
-                16,
-                41,
-                20,
-                142,
-                13,
-                131,
-                11,
-                90,
-                19,
-                153,
-                218,
-                255,
-                16,
-                132,
-                4,
-                142,
-                123,
-                216,
-                219,
-                233,
-                248,
-                89
-              ]
-            }
-          }
+          "name": "share_mint",
+          "writable": true
         },
         {
           "name": "fee_collector"
         },
         {
-          "name": "fee_collector_fee_asset_ata",
+          "name": "fee_collector_share_ata",
           "writable": true,
           "pda": {
             "seeds": [
@@ -2008,11 +1959,11 @@ var IDL = {
               },
               {
                 "kind": "account",
-                "path": "fee_asset_token_program"
+                "path": "share_token_program"
               },
               {
                 "kind": "account",
-                "path": "fee_asset_mint"
+                "path": "share_mint"
               }
             ],
             "program": {
@@ -2058,7 +2009,7 @@ var IDL = {
           "name": "protocol_fee_collector"
         },
         {
-          "name": "protocol_fee_collector_fee_asset_ata",
+          "name": "protocol_fee_collector_share_ata",
           "writable": true,
           "pda": {
             "seeds": [
@@ -2068,11 +2019,11 @@ var IDL = {
               },
               {
                 "kind": "account",
-                "path": "fee_asset_token_program"
+                "path": "share_token_program"
               },
               {
                 "kind": "account",
-                "path": "fee_asset_mint"
+                "path": "share_mint"
               }
             ],
             "program": {
@@ -2115,7 +2066,7 @@ var IDL = {
           }
         },
         {
-          "name": "fee_asset_token_program"
+          "name": "share_token_program"
         },
         {
           "name": "associated_token_program",
@@ -2998,7 +2949,9 @@ var IDL = {
         {
           "name": "share_mint",
           "docs": [
-            "Curator-supplied share mint. Its decimals must match `asset_mint`.",
+            "Curator-supplied share mint. Its decimals define the vault accounting",
+            "precision. `asset_mint` may use a different precision, which is stored",
+            "on its holding and handled by holding-price conversion.",
             "Unless `for_migration`, it must have zero supply with mint authority on",
             "the curator; authority is transferred to the vault PDA on success.",
             "Migration uses the legacy bank mint and defers transfer."
@@ -3222,8 +3175,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The mint fee",
-            "accrues here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -3517,8 +3470,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The mint fee",
-            "accrues here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -4013,8 +3966,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. Mint fees",
-            "accrue here and are swept by the permissionless fee crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -4315,8 +4268,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. Mint fees",
-            "accrue here and are swept by the permissionless fee crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -5106,8 +5059,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The burn fee accrues",
-            "here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -5395,8 +5348,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The burn fee accrues",
-            "here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -5690,8 +5643,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The burn fee accrues",
-            "here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -5995,8 +5948,8 @@ var IDL = {
         {
           "name": "fee_vault",
           "docs": [
-            "Per-vault fee-vault PDA: token authority + accounting. The burn fee accrues",
-            "here and is swept to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -7417,9 +7370,6 @@ var IDL = {
         },
         {
           "name": "idle_bank_tranche",
-          "docs": [
-            "path rejects initialized state because it cannot represent junior claims."
-          ],
           "pda": {
             "seeds": [
               {
@@ -7578,7 +7528,7 @@ var IDL = {
         {
           "name": "yielding_bank_tranche",
           "docs": [
-            "state so an active senior-price regime cannot be hidden by omission."
+            "tranche was already consumed by its regular vault migrations."
           ],
           "pda": {
             "seeds": [
@@ -7756,9 +7706,6 @@ var IDL = {
         },
         {
           "name": "vault_tranche_state",
-          "docs": [
-            "be initialized and consistent with destination.tranching_enabled."
-          ],
           "writable": true,
           "pda": {
             "seeds": [
@@ -9782,6 +9729,69 @@ var IDL = {
         }
       ]
     },
+    {
+      "name": "trigger_bank_circuit_breaker",
+      "discriminator": [
+        250,
+        236,
+        165,
+        211,
+        181,
+        241,
+        74,
+        84
+      ],
+      "accounts": [
+        {
+          "name": "bank_state",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  66,
+                  65,
+                  78,
+                  75
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "bank_state"
+              }
+            ]
+          }
+        },
+        {
+          "name": "bank_manager",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        },
+        {
+          "name": "token_program",
+          "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      "args": [
+        {
+          "name": "is_halted",
+          "type": "bool"
+        },
+        {
+          "name": "is_halted_deposit",
+          "type": "bool"
+        },
+        {
+          "name": "is_halted_withdrawal",
+          "type": "bool"
+        }
+      ]
+    },
     {
       "name": "trigger_vault_circuit_breaker",
       "discriminator": [
@@ -10543,8 +10553,8 @@ var IDL = {
         {
           "name": "destination_fee_vault",
           "docs": [
-            "Destination vault's fee-vault PDA: the mint fee accrues here and is swept",
-            "to the fee collector by the permissionless crank."
+            "Legacy fee-vault account retained in this instruction's account schema.",
+            "New fees accrue as pending vault shares."
           ],
           "writable": true
         },
@@ -11029,224 +11039,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": 14002,
+      "name": "InvalidBankMint",
+      "msg": "Invalid mint"
     },
     {
-      "code": 6001,
-      "name": "InvalidAssetMint",
-      "msg": "Supplied mint is not accepted by this vault"
+      "code": 14003,
+      "name": "AccountingIssue",
+      "msg": "Accounting issue"
     },
     {
-      "code": 6002,
-      "name": "ZeroDepositAmount",
-      "msg": "Deposit amount must be greater than zero"
+      "code": 14004,
+      "name": "VaultAccountingIssue",
+      "msg": "Vault accounting issue"
     },
     {
-      "code": 6003,
-      "name": "ExceedsTvlLimit",
-      "msg": "Deposit would exceed the vault's TVL limit"
+      "code": 14005,
+      "name": "BankAccountingIssue",
+      "msg": "Bank accounting issue"
     },
     {
-      "code": 6004,
-      "name": "ZeroBurnAmount",
-      "msg": "Burn amount must be greater than zero"
+      "code": 14006,
+      "name": "OnchainAccountingIssue",
+      "msg": "Onchain accounting issue"
     },
     {
-      "code": 6005,
-      "name": "ZeroAssetAmount",
-      "msg": "Asset amount must be greater than zero"
+      "code": 14007,
+      "name": "ExternalAccountingIssue",
+      "msg": "External accounting issue"
     },
     {
-      "code": 6006,
-      "name": "InsufficientVaultLiquidity",
-      "msg": "Insufficient vault liquidity to satisfy withdrawal"
+      "code": 14008,
+      "name": "MintSlippage",
+      "msg": "Minting failed due to slippage."
     },
     {
-      "code": 6007,
-      "name": "MintAuthorityNotCurator",
-      "msg": "Mint authority is not the curator"
+      "code": 14009,
+      "name": "BurningSlippage",
+      "msg": "Burning failed due to slippage."
     },
     {
-      "code": 6008,
-      "name": "ZeroTotalSupply",
-      "msg": "Vault total supply is zero"
+      "code": 14010,
+      "name": "TeamAccountAlreadyExists",
+      "msg": "Team account already exists"
     },
     {
-      "code": 6009,
+      "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,
-      "name": "WithdrawalQueueNotExpired",
-      "msg": "Withdrawal queue is not yet expired"
+      "code": 14034,
+      "name": "JuniorTrancheEmpty",
+      "msg": "Junior tranche has no value"
     },
     {
-      "code": 6032,
-      "name": "InvalidWithdrawalQueue",
-      "msg": "Invalid withdrawal queue"
+      "code": 14035,
+      "name": "InvalidTrancheConfig",
+      "msg": "Invalid tranche config parameter"
+    },
+    {
+      "code": 14036,
+      "name": "WithdrawalQueueNotExpired",
+      "msg": "Withdrawal queue lockup period has not expired"
     },
     {
-      "code": 6033,
-      "name": "AssetPriceNotSet",
-      "msg": "Destination asset has no price set; a consensus oracle price is required before swapping"
+      "code": 14037,
+      "name": "InvalidWithdrawalQueue",
+      "msg": "Withdrawal queue entry is not in a valid state"
     },
     {
-      "code": 6034,
-      "name": "AssetHoldingNotEmpty",
-      "msg": "Asset holding still has a balance and cannot be removed"
+      "code": 14038,
+      "name": "InvalidAccount",
+      "msg": "Account does not belong to the expected parent"
     },
     {
-      "code": 6035,
-      "name": "CannotRemoveBaseHolding",
-      "msg": "The base asset holding cannot be removed"
+      "code": 14039,
+      "name": "MissingAccount",
+      "msg": "Required optional account is missing"
     },
     {
-      "code": 6036,
-      "name": "UnauthorizedPriceUpdater",
-      "msg": "Caller is not authorized to trigger an asset price update"
+      "code": 14040,
+      "name": "TrancheWipedOut",
+      "msg": "Junior tranche is wiped out and cannot accept new stakes"
     },
     {
-      "code": 6037,
-      "name": "InvalidStalenessConfig",
-      "msg": "Invalid asset-price staleness threshold"
+      "code": 14041,
+      "name": "VaultLossNotAccepted",
+      "msg": "Vault does not accept losses \u2014 enable losses_accepted before retrying"
     },
     {
-      "code": 6038,
-      "name": "AssetRebalanceRateLimitExceeded",
-      "msg": "Asset was rebalanced too recently"
+      "code": 14042,
+      "name": "CapitalLossExceedsReserve",
+      "msg": "Capital loss exceeds available yielding reserve"
     },
     {
-      "code": 6039,
-      "name": "InvalidShareTokenProgram",
-      "msg": "Share token program does not match the vault/tranche mint configuration"
+      "code": 14043,
+      "name": "RollingWithdrawalLimitExceeded",
+      "msg": "Rolling withdrawal limit exceeded"
     },
     {
-      "code": 6040,
-      "name": "UnauthorizedVaultCreator",
-      "msg": "Caller is not on the vault-creator whitelist"
+      "code": 14044,
+      "name": "VaultAlreadyMigrated",
+      "msg": "Legacy vault has already been migrated"
     },
     {
-      "code": 6041,
-      "name": "InvalidShareMintDecimals",
-      "msg": "Share mint decimals must match the deposit asset mint decimals"
+      "code": 14045,
+      "name": "InvalidMigrationState",
+      "msg": "Legacy vault migration is incomplete or invalid"
     },
     {
-      "code": 6042,
-      "name": "InvalidFeeExemption",
-      "msg": "Invalid fee-exemption PDA signer or seeds"
+      "code": 14046,
+      "name": "InvalidMigrationMintAuthority",
+      "msg": "Mint authority does not match the expected migration source"
     },
     {
-      "code": 6043,
-      "name": "ExceedsJuniorDepositCap",
-      "msg": "Deposit would exceed the junior tranche deposit cap"
+      "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": [
@@ -11846,21 +11871,11 @@ var IDL = {
     {
       "name": "FeeVault",
       "docs": [
-        "Per-vault fee custody + accounting account.",
-        "",
-        "The PDA is both the token authority over the fee-asset ATAs that physically",
-        "hold accrued fees and the ledger of what is owed to whom. All four fee types",
-        "\u2014 mint, burn, performance, and protocol \u2014 accrue here.",
-        "",
-        "Ledger amounts (`*_owed` / `*_collected`) are denominated in the vault's",
-        "**accounting unit** (the same unit as TVL / holding prices), not raw token",
-        "units. Token custody may still be split across ATAs for different base-asset",
-        "mints; the permissionless fee crank converts each ATA's balance to accounting",
-        "value via that mint's fresh holding price, pays out, and reduces these",
-        "counters by the accounting value cleared.",
+        "Legacy per-vault fee custody account.",
         "",
-        "Mint/burn/performance go to `vault.roles.fee_collector`, protocol goes to the",
-        "hardcoded protocol fee recipient."
+        "New fee accrual is denominated in canonical vault shares and stored on",
+        "`VaultAccounting`. This account remains in existing instruction schemas for",
+        "compatibility; its historical accounting-unit counters are no longer updated."
       ],
       "serialization": "bytemuck",
       "repr": {
@@ -12085,8 +12100,9 @@ var IDL = {
           {
             "name": "migrate_amount",
             "docs": [
-              "Reserved for partial migration; partial migration is unsupported, so this",
-              "must be `None` (a full vault migration). A `Some(_)` value is rejected."
+              "Partial migration remains unsupported. `None` performs a regular full",
+              "vault migration; `Some(0)` explicitly marks the final in-scope vault and",
+              "permits bounded terminal source-accounting reconciliation."
             ],
             "type": {
               "option": "u64"
@@ -13390,10 +13406,16 @@ var IDL = {
             }
           },
           {
-            "name": "_padding_bool",
+            "name": "migration_in_progress",
             "docs": [
-              "Reserved padding (previously `apy_settle_skip`). Kept as a field to",
-              "preserve the on-chain account layout for already-deployed vaults."
+              "True while a legacy migration destination is still receiving backing",
+              "and receipt-supply accounting. Oracle mutation and NAV settlement stay",
+              "disabled until every configured receipt mint authority has moved to this vault",
+              "and migration finalization clears the flag.",
+              "",
+              "This occupies the former `apy_settle_skip` padding byte, preserving the",
+              "on-chain account layout for already-deployed vaults. Existing vaults read",
+              "it as false."
             ],
             "type": {
               "defined": {
@@ -13704,7 +13726,7 @@ var IDL = {
           {
             "name": "tvl_limit",
             "docs": [
-              "Maximum TVL in deposit-asset base units. `0` disables the cap."
+              "Maximum TVL in vault accounting units. `0` disables the cap."
             ],
             "type": "u64"
           },
@@ -14764,7 +14786,7 @@ var IDL = {
           {
             "name": "total_mint_supply",
             "docs": [
-              "Total supply of the vault's share mint."
+              "Effective share supply: physical mint supply plus unminted fee shares."
             ],
             "type": "u64"
           },
@@ -14818,12 +14840,26 @@ var IDL = {
               }
             }
           },
+          {
+            "name": "pending_curator_fee_shares",
+            "docs": [
+              "Vault shares owed to the curator but not yet minted."
+            ],
+            "type": "u64"
+          },
+          {
+            "name": "pending_protocol_fee_shares",
+            "docs": [
+              "Vault shares owed to the protocol but not yet minted."
+            ],
+            "type": "u64"
+          },
           {
             "name": "_padding1",
             "type": {
               "array": [
                 "u64",
-                32
+                30
               ]
             }
           },
@@ -14872,8 +14908,8 @@ var IDL = {
           {
             "name": "asset_decimals",
             "docs": [
-              "Decimals of the deposit asset, cached so deposit/withdraw paths don't",
-              "need to deserialize the mint account."
+              "Vault accounting precision. This matches the vault share mint; each",
+              "holding stores its own mint precision independently."
             ],
             "type": "u8"
           },
@@ -14905,7 +14941,7 @@ var IDL = {
           {
             "name": "tvl_limit",
             "docs": [
-              "Maximum TVL in deposit-asset base units. `0` disables the cap."
+              "Maximum TVL in vault accounting units. `0` disables the cap."
             ],
             "type": "u64"
           },
@@ -15689,8 +15725,8 @@ function coerceBool(value) {
   if (value && typeof value.toBool === "function") {
     return value.toBool();
   }
-  const record = value;
-  return Boolean(record?.value ?? record?.[0]);
+  const record2 = value;
+  return Boolean(record2?.value ?? record2?.[0]);
 }
 
 // src/client/builders/base.ts
@@ -15726,8 +15762,8 @@ function coerceBool2(value) {
   if (value && typeof value.toBool === "function") {
     return value.toBool();
   }
-  const record = value;
-  return Boolean(record?.value ?? record?.[0]);
+  const record2 = value;
+  return Boolean(record2?.value ?? record2?.[0]);
 }
 function pubkeyToAddress(value) {
   if (typeof value === "string") return (0, import_kit5.address)(value);
@@ -15737,8 +15773,8 @@ function pubkeyToAddress(value) {
   return (0, import_kit5.address)(String(value));
 }
 function tokenProgramAddressFromIdlEnum(value) {
-  const record = value;
-  if (record && "token2022" in record) {
+  const record2 = value;
+  if (record2 && "token2022" in record2) {
     return TOKEN_PROGRAM_ID;
   }
   return (0, import_kit5.address)(import_spl_token2.TOKEN_PROGRAM_ID.toBase58());
@@ -16112,7 +16148,7 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
     const [vault] = await this.pda.deriveVaultPda(vaultId);
     const [vaultOracle] = await this.pda.deriveVaultOraclePda(vault);
     const [feeVault] = await this.pda.deriveFeeAuthorityPda(vault);
-    const assetDecimals = (await (0, import_token.fetchMint)(this.rpc, txArgs.strictAssetMint)).data.decimals;
+    const accountingDecimals = (await (0, import_token.fetchMint)(this.rpc, txArgs.shareMint)).data.decimals;
     return {
       curator: txArgs.curator,
       vault,
@@ -16137,7 +16173,7 @@ var CreateVaultBuilder = class extends VaultBuilderBase {
         initialMintSharePrice: null,
         basePriceOracleType: txArgs.basePriceOracleType ?? 1,
         basePrice: new import_core3.BN(
-          (txArgs.basePrice ?? 10n ** BigInt(assetDecimals)).toString()
+          (txArgs.basePrice ?? 10n ** BigInt(accountingDecimals)).toString()
         ),
         basePriceOracleAccount: txArgs.basePriceOracleAccount ?? DEFAULT_PRICE_ORACLE_ACCOUNT,
         forMigration: txArgs.forMigration ?? false
@@ -16313,8 +16349,9 @@ var SetProtocolFeeBuilder = class extends VaultBuilderBase {
     const [derivedVaultOracle] = await this.pda.deriveVaultOraclePda(
       txArgs.vault
     );
+    const defaultProtocolAuthority = this.program.programId.toBase58() === VAULT_PROGRAM_ID ? LOCAL_PROTOCOL_ADMIN : PROTOCOL_ADMIN;
     return {
-      protocolAuthority: txArgs.protocolAuthority ?? PROTOCOL_ADMIN,
+      protocolAuthority: txArgs.protocolAuthority ?? defaultProtocolAuthority,
       vault: txArgs.vault,
       vaultOracle: txArgs.vaultOracle ?? derivedVaultOracle,
       args: {
@@ -16511,82 +16548,53 @@ var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
     return this.program.methods.crankPerformanceFees().accountsPartial({
       cranker: (0, import_common18.toWeb3Pk)(args.cranker),
       vault: (0, import_common18.toWeb3Pk)(args.vault),
-      feeAssetMint: (0, import_common18.toWeb3Pk)(args.feeAssetMint),
-      feeVault: (0, import_common18.toWeb3Pk)(args.feeVault),
-      feeVaultAta: (0, import_common18.toWeb3Pk)(args.feeVaultAta),
+      shareMint: (0, import_common18.toWeb3Pk)(args.shareMint),
       feeCollector: (0, import_common18.toWeb3Pk)(args.feeCollector),
-      feeCollectorFeeAssetAta: (0, import_common18.toWeb3Pk)(args.feeCollectorFeeAssetAta),
+      feeCollectorShareAta: (0, import_common18.toWeb3Pk)(args.feeCollectorShareAta),
       protocolFeeCollector: (0, import_common18.toWeb3Pk)(args.protocolFeeCollector),
-      protocolFeeCollectorFeeAssetAta: (0, import_common18.toWeb3Pk)(
-        args.protocolFeeCollectorFeeAssetAta
+      protocolFeeCollectorShareAta: (0, import_common18.toWeb3Pk)(
+        args.protocolFeeCollectorShareAta
       ),
-      feeAssetTokenProgram: (0, import_common18.toWeb3Pk)(args.feeAssetTokenProgram),
+      shareTokenProgram: (0, import_common18.toWeb3Pk)(args.shareTokenProgram),
       associatedTokenProgram: import_spl_token6.ASSOCIATED_TOKEN_PROGRAM_ID,
       systemProgram: import_web38.SystemProgram.programId
     }).instruction().then(import_common18.toKitInstruction);
   }
   async deriveIxArgs(txArgs) {
-    const feeAssetMint = await resolveVaultBaseAssetMint(
+    const vaultState = await this.account.fetchVault(txArgs.vault);
+    const shareMint = (0, import_common18.fromWeb3Pk)(vaultState.mint);
+    const shareTokenProgram = txArgs.shareTokenProgram ?? tokenProgramAddressFromIdlEnum(vaultState.mintTokenProgram);
+    const feeCollector = await resolveVaultFeeCollector(
       this.account,
       txArgs.vault,
-      txArgs.feeAssetMint
+      txArgs.feeCollector
     );
-    const [feeVault] = await this.pda.deriveFeeAuthorityPda(txArgs.vault);
-    const [feeCollector, feeAssetTokenProgram] = await Promise.all([
-      resolveVaultFeeCollector(this.account, txArgs.vault, txArgs.feeCollector),
-      resolveFeeAssetTokenProgram(
-        this.account,
-        txArgs.vault,
-        feeAssetMint,
-        txArgs.feeAssetTokenProgram
-      )
-    ]);
     const protocolFeeCollector = resolveProtocolFeeRecipient(
       txArgs.protocolFeeCollector
     );
     return {
       cranker: txArgs.cranker,
       vault: txArgs.vault,
-      feeAssetMint,
-      feeVault,
-      feeVaultAta: (0, import_common18.getAtaAddress)(
-        feeAssetMint,
-        feeVault,
-        feeAssetTokenProgram,
-        true
-      ),
+      shareMint,
       feeCollector,
-      feeCollectorFeeAssetAta: (0, import_common18.getAtaAddress)(
-        feeAssetMint,
+      feeCollectorShareAta: (0, import_common18.getAtaAddress)(
+        shareMint,
         feeCollector,
-        feeAssetTokenProgram
+        shareTokenProgram
       ),
       protocolFeeCollector,
       // 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.
-      protocolFeeCollectorFeeAssetAta: (0, import_common18.getAtaAddress)(
-        feeAssetMint,
+      protocolFeeCollectorShareAta: (0, import_common18.getAtaAddress)(
+        shareMint,
         protocolFeeCollector,
-        feeAssetTokenProgram,
+        shareTokenProgram,
         true
       ),
-      feeAssetTokenProgram
+      shareTokenProgram
     };
   }
-  async buildPreambleInstructions(args) {
-    const payer = (0, import_common18.toWeb3Pk)(args.cranker);
-    return [
-      (0, import_spl_token6.createAssociatedTokenAccountIdempotentInstruction)(
-        payer,
-        (0, import_common18.toWeb3Pk)(args.feeVaultAta),
-        (0, import_common18.toWeb3Pk)(args.feeVault),
-        (0, import_common18.toWeb3Pk)(args.feeAssetMint),
-        (0, import_common18.toWeb3Pk)(args.feeAssetTokenProgram),
-        import_spl_token6.ASSOCIATED_TOKEN_PROGRAM_ID
-      )
-    ].map(import_common18.toKitInstruction);
-  }
   async buildPlanExtras(args) {
     return {
       postSuccessCacheInvalidations: [{ vaultPda: args.vault }]
@@ -16594,11 +16602,10 @@ var CrankPerformanceFeesBuilder = class extends VaultBuilderBase {
   }
   async getTx(txArgs) {
     const args = await this.deriveIxArgs(txArgs);
-    const preambleInstructions = await this.buildPreambleInstructions(args);
     const instruction = await this.getIx(args);
     const extras = await this.buildPlanExtras(args);
     return {
-      instructions: [...preambleInstructions, instruction],
+      instructions: [instruction],
       ...extras ?? {}
     };
   }
@@ -18158,7 +18165,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),
@@ -18193,7 +18200,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),
@@ -18212,7 +18219,7 @@ var VaultReallocationBuilder = class extends VaultBuilderBase {
         )
       );
     }
-    return instructions.map(import_common34.toKitInstruction);
+    return instructions2.map(import_common34.toKitInstruction);
   }
   async buildPlanExtras(args) {
     return {
@@ -18447,15 +18454,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,
@@ -18481,7 +18602,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);
@@ -18520,7 +18641,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]);
 }
 
@@ -18793,8 +18914,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)
     );
   }
@@ -19153,21 +19274,85 @@ var JupiterPriceSource = class {
   }
 };
 
-// src/services/consensusOracle/jupiterBalanceSource.ts
-var import_web322 = 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";
-var JupiterBalanceSource = class {
-  constructor(connection, opts = {}) {
-    this.connection = connection;
-    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL2;
-    this.fetchFn = opts.fetchFn ?? fetch;
-    this.rpcOnly = opts.rpcOnly ?? false;
-    this.log = opts.log ?? (() => {
-    });
-  }
-  async fetchBalances(owner) {
+// src/services/consensusOracle/nestPriceSource.ts
+var import_kit12 = require("@solana/kit");
+var NEST_API_BASE_URL = "https://api.nest.credit/v1";
+var NEST_VAULT_SLUG = "nest-perena-vault";
+var NEST_RWA_SHARE_MINT = (0, import_kit12.address)(
+  "VyXKJnVhkSkB6KAozSZCiLQbuB1k1r6Nu4etNYVo5LJ"
+);
+async function fetchNestTokenPrice(nestVaultSlug = NEST_VAULT_SLUG, opts = {}) {
+  const baseUrl = (opts.baseUrl ?? NEST_API_BASE_URL).replace(/\/$/, "");
+  const response = await (opts.fetchFn ?? fetch)(
+    `${baseUrl}/vaults/${encodeURIComponent(nestVaultSlug)}/price`
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Nest price API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const body = await response.json();
+  const price = [body.data?.interpolatedPrice, body.data?.price].map(Number).find((candidate) => Number.isFinite(candidate) && candidate > 0);
+  if (price === void 0) {
+    throw new Error("Nest price API returned no positive share price");
+  }
+  return price;
+}
+var NestPriceSource = class {
+  constructor(opts = {}) {
+    this.shareMint = opts.shareMint ?? NEST_RWA_SHARE_MINT;
+    this.nestVaultSlug = opts.nestVaultSlug ?? NEST_VAULT_SLUG;
+    this.options = { baseUrl: opts.baseUrl, fetchFn: opts.fetchFn };
+  }
+  async fetchUsdPrices(mints) {
+    if (!mints.some((mint) => mint.toString() === this.shareMint.toString())) {
+      return {};
+    }
+    return {
+      [this.shareMint.toString()]: await fetchNestTokenPrice(
+        this.nestVaultSlug,
+        this.options
+      )
+    };
+  }
+};
+
+// src/services/consensusOracle/livePriceSource.ts
+var LivePriceSource = class {
+  constructor(opts = {}) {
+    this.jupiter = opts.jupiter ?? new JupiterPriceSource();
+    this.nest = opts.nest ?? new NestPriceSource();
+  }
+  async fetchUsdPrices(mints) {
+    const unique = [
+      ...new Map(mints.map((mint) => [mint.toString(), mint])).values()
+    ];
+    const nestMint = this.nest.shareMint.toString();
+    const jupiterMints = unique.filter((mint) => mint.toString() !== nestMint);
+    const nestMints = unique.filter((mint) => mint.toString() === nestMint);
+    const [jupiterPrices, nestPrices] = await Promise.all([
+      this.jupiter.fetchUsdPrices(jupiterMints),
+      this.nest.fetchUsdPrices(nestMints)
+    ]);
+    return { ...jupiterPrices, ...nestPrices };
+  }
+};
+
+// src/services/consensusOracle/jupiterBalanceSource.ts
+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";
+var JupiterBalanceSource = class {
+  constructor(connection, opts = {}) {
+    this.connection = connection;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL2;
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.rpcOnly = opts.rpcOnly ?? false;
+    this.log = opts.log ?? (() => {
+    });
+  }
+  async fetchBalances(owner) {
     if (!this.rpcOnly) {
       try {
         const fromJup = await this.fetchFromJupiter(owner);
@@ -19211,7 +19396,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;
@@ -19261,12 +19446,12 @@ var StaticPositionProvider = class {
 };
 
 // src/services/consensusOracle/kaminoPositionProvider.ts
-var import_kit12 = require("@solana/kit");
-var import_web323 = require("@solana/web3.js");
+var import_kit13 = require("@solana/kit");
+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(
-    (0, import_kit12.address)(sharesHolder.toBase58()),
+    (0, import_kit13.address)(sharesHolder.toBase58()),
     vault
   );
   const tokensPerShare = await manager.getTokensPerShareSingleVault(vault);
@@ -19282,7 +19467,7 @@ var KaminoPositionProvider = class {
   async positionsFor(ctx) {
     const refs = ctx.refs.filter((r) => r.kind === "kamino");
     if (refs.length === 0) return [];
-    const rpc = (0, import_kit12.createSolanaRpc)(this.rpcUrl);
+    const rpc = (0, import_kit13.createSolanaRpc)(this.rpcUrl);
     const slotDuration = await (0, import_klend_sdk.getMedianSlotDurationInMsFromLastEpochs)();
     const manager = new import_klend_sdk.KaminoManager(rpc, slotDuration);
     const out = [];
@@ -19295,11 +19480,11 @@ var KaminoPositionProvider = class {
         );
         continue;
       }
-      const kVault = new import_klend_sdk.KaminoVault(rpc, (0, import_kit12.address)(vaultState));
+      const kVault = new import_klend_sdk.KaminoVault(rpc, (0, import_kit13.address)(vaultState));
       const amount = await readKaminoBalance(
         manager,
         kVault,
-        new import_web323.PublicKey(sharesHolder)
+        new import_web324.PublicKey(sharesHolder)
       );
       out.push({ mint: ref.mint, amount });
     }
@@ -19308,7 +19493,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;
@@ -19321,7 +19506,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;
 }
@@ -19359,8 +19544,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 {
@@ -19391,14 +19576,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 });
@@ -19414,11 +19599,15 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
   const log = opts.log ?? (() => {
   });
   const deps = {
-    priceSource: new JupiterPriceSource(),
+    priceSource: new LivePriceSource(),
     balanceSource: new JupiterBalanceSource(connection, {
       rpcOnly: opts.rpcOnly ?? false,
       log
-    })
+    }),
+    yieldTracker: {
+      getTotalOutstandingYield,
+      getYieldPayments
+    }
   };
   if (opts.includeExternalPositions ?? true) {
     deps.externalPositions = new ExternalPositionRegistry(
@@ -19433,8 +19622,861 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
 }
 
 // src/services/consensusOracle/consensusOracleService.ts
-var import_web325 = require("@solana/web3.js");
+var import_web327 = require("@solana/web3.js");
 var import_common41 = __toESM(require_dist());
+
+// src/services/consensusOracle/settlementSimulator.ts
+var import_kit14 = require("@solana/kit");
+var import_web326 = require("@solana/web3.js");
+var DEFAULT_SHARE_PRICE = 1000000n;
+var BPS_DENOMINATOR2 = 10000n;
+var SECONDS_PER_YEAR = 31536000n;
+var DEFAULT_STALENESS_SECS = 86400n;
+var CONSENSUS_MAX_DIFF_BPS = 8n;
+var MIN_CONSENSUS_SIGNERS = 2;
+var MAX_HOLDINGS = 12;
+var MAX_SIGNERS = 4;
+var ENTRY_SIZE = 272;
+var ENTRIES_OFFSET = 40;
+var PRICE_OFFSET = 40;
+var EXTERNAL_OFFSET = PRICE_OFFSET + MAX_HOLDINGS * 8;
+var APY_SCALE = 1000000000000000000n;
+var APY_LN_2 = 693147180559945309n;
+var APY_SERIES_TERMS = 32;
+function simulateConsensusOracleSettlement(args) {
+  const warnings = [];
+  const blockers = [];
+  const vaultAccounting = record(args.vault.accounting);
+  const feesConfig = record(args.vault.config.fees);
+  const apyConfig = record(args.vault.config.apy);
+  const tranchingEnabled = bool(args.vault.tranchingEnabled);
+  const currentTvl = bigint(vaultAccounting.tvl);
+  const pendingCuratorShares = bigint(vaultAccounting.pendingCuratorFeeShares);
+  const pendingProtocolShares = bigint(
+    vaultAccounting.pendingProtocolFeeShares
+  );
+  const cachedSupply = bigint(vaultAccounting.totalMintSupply);
+  const reconciledSupply = args.physicalShareSupply === void 0 ? cachedSupply : args.physicalShareSupply + pendingCuratorShares + pendingProtocolShares;
+  if (args.physicalShareSupply === void 0) {
+    warnings.push(
+      "regular share-mint supply was unavailable; using cached effective supply"
+    );
+  } else if (reconciledSupply !== cachedSupply) {
+    warnings.push(
+      `crank supply reconciliation changes regular supply ${cachedSupply} -> ${reconciledSupply}`
+    );
+  }
+  const holdings = args.vault.holdings.map(decodeHolding);
+  const oracle = decodeOracleData(args.oracleData, args.nowTs);
+  const signerEntry = oracle.entries.find(
+    (entry) => entry.signer === args.signer.toString()
+  );
+  if (!signerEntry) {
+    blockers.push(`signer ${args.signer} is not registered in the oracle`);
+  } else {
+    signerEntry.lastUpdateTs = args.nowTs;
+    for (const update of args.updates) {
+      signerEntry.prices[update.holdingIndex] = update.price;
+      signerEntry.externalAmounts[update.holdingIndex] = update.externalAmount;
+    }
+  }
+  const consensus = applyConsensus(
+    holdings,
+    oracle.entries,
+    args.nowTs,
+    oracle.stalenessThresholdSecs
+  );
+  const proposedUpdatesLanded = args.updates.filter(
+    (update) => consensus.find(
+      (result) => result.holdingIndex === update.holdingIndex && result.wouldUpdateHolding
+    )
+  ).length;
+  const consensusSummary = {
+    allProposedUpdatesLand: proposedUpdatesLanded === args.updates.length && args.updates.length > 0,
+    proposedUpdatesLanded,
+    proposedUpdatesTotal: args.updates.length
+  };
+  const currentTranche = tranchingEnabled ? decodeTrancheState(args.trancheState, args, warnings, blockers) : void 0;
+  const current = snapshot(
+    currentTvl,
+    reconciledSupply,
+    bigint(vaultAccounting.mintSharePrice),
+    currentTranche
+  );
+  let grossNav;
+  try {
+    grossNav = grossNavFromHoldings(
+      holdings,
+      args.nowTs,
+      positiveOrDefault(
+        bigint(args.vault.config.priceStalenessThresholdSecs),
+        DEFAULT_STALENESS_SECS
+      )
+    );
+  } catch (error) {
+    blockers.push(message(error));
+  }
+  if (grossNav === void 0 || blockers.length > 0) {
+    return {
+      nowTs: args.nowTs,
+      assetDecimals: args.vault.config.assetDecimals,
+      ...consensusSummary,
+      canSettle: false,
+      blockers,
+      warnings,
+      consensus,
+      grossNav,
+      current
+    };
+  }
+  try {
+    const settlement = settleVault({
+      grossNav,
+      nowTs: args.nowTs,
+      currentTvl,
+      currentSharePrice: bigint(vaultAccounting.mintSharePrice),
+      totalSupply: reconciledSupply,
+      lossesEnabled: bool(args.vault.lossesEnabled),
+      accountingLastUpdateTs: bigint(vaultAccounting.lastUpdateTs),
+      priorSettledNavTs: oracle.settledNavTs,
+      performanceFeeBps: number(feesConfig.performanceFeeBps),
+      protocolFeeBps: number(feesConfig.protocolFeeBps),
+      hwmSharePrice: bigint(vaultAccounting.hwmSharePrice),
+      fixedApyBps: number(apyConfig.fixedApyBps),
+      maxApyBps: number(apyConfig.maxApyBps),
+      apyAnchorSharePrice: bigint(apyConfig.anchorSharePrice),
+      apyAnchorTs: bigint(apyConfig.anchorTs),
+      tranche: currentTranche
+    });
+    return {
+      nowTs: args.nowTs,
+      assetDecimals: args.vault.config.assetDecimals,
+      ...consensusSummary,
+      canSettle: true,
+      blockers,
+      warnings,
+      consensus,
+      grossNav,
+      settledAccountingNav: settlement.settledAccountingNav,
+      current,
+      projected: settlement.projected,
+      performanceFees: settlement.performanceFees
+    };
+  } catch (error) {
+    blockers.push(message(error));
+    return {
+      nowTs: args.nowTs,
+      assetDecimals: args.vault.config.assetDecimals,
+      ...consensusSummary,
+      canSettle: false,
+      blockers,
+      warnings,
+      consensus,
+      grossNav,
+      current
+    };
+  }
+}
+function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
+  const results = [];
+  for (let index = 0; index < holdings.length; index += 1) {
+    const holding = holdings[index];
+    if (holding.cleared || holding.priceOracleType !== "consensusoracle") {
+      continue;
+    }
+    const reports = entries.filter(
+      (entry) => entry.signer !== import_web326.PublicKey.default.toBase58() && isFresh(entry.lastUpdateTs, nowTs, stalenessThresholdSecs) && (entry.prices[index] ?? 0n) > 0n
+    );
+    const prices = reports.map((entry) => entry.prices[index] ?? 0n);
+    const amounts = reports.map((entry) => entry.externalAmounts[index] ?? 0n);
+    let reason;
+    if (reports.length < MIN_CONSENSUS_SIGNERS) {
+      reason = `only ${reports.length} fresh priced report(s); need ${MIN_CONSENSUS_SIGNERS}`;
+    } else if (!withinDeviation(prices)) {
+      reason = `price reports exceed ${CONSENSUS_MAX_DIFF_BPS}bps pairwise deviation`;
+    } else if (!withinDeviation(amounts)) {
+      reason = `external-amount reports exceed ${CONSENSUS_MAX_DIFF_BPS}bps pairwise deviation`;
+    }
+    if (reason) {
+      results.push({
+        holdingIndex: index,
+        mint: holding.mint,
+        reportCount: reports.length,
+        wouldUpdateHolding: false,
+        reason
+      });
+      continue;
+    }
+    const settledPrice = average(prices);
+    const settledExternalAmount = average(amounts);
+    const latestTs = reports.reduce(
+      (latest, entry) => entry.lastUpdateTs > latest ? entry.lastUpdateTs : latest,
+      0n
+    );
+    const wouldUpdateHolding = latestTs > holding.lastUpdateTs && latestTs <= nowTs;
+    if (wouldUpdateHolding) {
+      holding.price = settledPrice;
+      holding.externalAmount = settledExternalAmount;
+      holding.lastUpdateTs = latestTs;
+      if (!holding.isBase && holding.localAmount === 0n && holding.externalAmount === 0n) {
+        holding.cleared = true;
+      }
+    }
+    results.push({
+      holdingIndex: index,
+      mint: holding.mint,
+      reportCount: reports.length,
+      settledPrice,
+      settledExternalAmount,
+      wouldUpdateHolding,
+      reason: wouldUpdateHolding ? void 0 : `aggregate timestamp ${latestTs} is not newer than holding timestamp ${holding.lastUpdateTs}`
+    });
+  }
+  return results;
+}
+function settleVault(args) {
+  if (args.grossNav < args.currentTvl && !args.lossesEnabled) {
+    throw new Error(
+      `crank would fail LossesDisabled: gross NAV ${args.grossNav} < current TVL ${args.currentTvl}`
+    );
+  }
+  const priorTs = args.priorSettledNavTs > 0n ? args.priorSettledNavTs : max(args.accountingLastUpdateTs, args.apyAnchorTs);
+  const nextApyValue = args.tranche ? args.grossNav : sharePriceForValue(args.grossNav, args.totalSupply);
+  if (nextApyValue !== void 0) {
+    validateRealizedApy(
+      args.tranche ? args.currentTvl : args.currentSharePrice,
+      priorTs,
+      nextApyValue,
+      args.nowTs,
+      args.maxApyBps
+    );
+  }
+  let regularValue;
+  let regularSharePrice = args.currentSharePrice;
+  let curatorFee = 0n;
+  let protocolFee = 0n;
+  let settledAccountingNav;
+  if (args.tranche) {
+    settledAccountingNav = args.grossNav;
+    regularValue = settleTrancheNav(
+      args.tranche,
+      args.currentTvl,
+      settledAccountingNav,
+      args.nowTs
+    );
+    const juniorFees = settleShareClassPerformanceFee(
+      args.tranche.junior,
+      args.performanceFeeBps,
+      args.protocolFeeBps
+    );
+    const regularFees = settleRegularPerformanceFee(
+      regularValue,
+      args.totalSupply,
+      args.hwmSharePrice,
+      args.performanceFeeBps,
+      args.protocolFeeBps
+    );
+    regularValue = regularFees.netValue;
+    regularSharePrice = sharePriceForValue(regularValue, args.totalSupply) ?? regularSharePrice;
+    curatorFee = juniorFees.curator + regularFees.fees.curator;
+    protocolFee = juniorFees.protocol + regularFees.fees.protocol;
+  } else {
+    settledAccountingNav = settleFixedApyNav({
+      currentSharePrice: args.currentSharePrice,
+      reportedNav: args.grossNav,
+      nowTs: args.nowTs,
+      totalSupply: args.totalSupply,
+      fixedApyBps: args.fixedApyBps,
+      anchorSharePrice: args.apyAnchorSharePrice,
+      anchorTs: args.apyAnchorTs
+    });
+    const regularFees = settleRegularPerformanceFee(
+      settledAccountingNav,
+      args.totalSupply,
+      args.hwmSharePrice,
+      args.performanceFeeBps,
+      args.protocolFeeBps
+    );
+    regularValue = regularFees.netValue;
+    regularSharePrice = sharePriceForValue(regularValue, args.totalSupply) ?? regularSharePrice;
+    curatorFee = regularFees.fees.curator;
+    protocolFee = regularFees.fees.protocol;
+  }
+  const totalFees = curatorFee + protocolFee;
+  const netRegularBacking = mulDiv2(
+    args.totalSupply,
+    regularSharePrice,
+    DEFAULT_SHARE_PRICE
+  );
+  let mintedShares = 0n;
+  if (totalFees > 0n) {
+    mintedShares = args.totalSupply === 0n ? totalFees : mulDiv2(totalFees, args.totalSupply, netRegularBacking);
+    if (mintedShares === 0n) {
+      throw new Error(
+        "crank would fail ZeroAssetAmount while accruing fee shares"
+      );
+    }
+  }
+  const projectedSupply = args.totalSupply + mintedShares;
+  const projected = snapshot(
+    // Fee value is carved out, then added back when converted to vault shares.
+    settledAccountingNav,
+    projectedSupply,
+    regularSharePrice,
+    args.tranche
+  );
+  return {
+    settledAccountingNav,
+    projected,
+    performanceFees: {
+      curator: curatorFee,
+      protocol: protocolFee,
+      total: totalFees,
+      mintedShares
+    }
+  };
+}
+function settleTrancheNav(tranche, currentTvl, nextTvl, nowTs) {
+  const before = tranche.junior.value + tranche.senior.value;
+  if (before === 0n) {
+    tranche.lastSettledTs = nowTs;
+    return nextTvl;
+  }
+  if (currentTvl <= 0n || before > currentTvl) {
+    throw new Error(
+      `crank would fail InvalidArgument: tranche value ${before}, current TVL ${currentTvl}`
+    );
+  }
+  const after = mulDiv2(before, nextTvl, currentTvl);
+  if (after >= before) {
+    let gain = after - before;
+    const entitlement = seniorEntitlement(tranche, nowTs);
+    const seniorGain = entitlement < gain ? entitlement : gain;
+    tranche.senior.value += seniorGain;
+    gain -= seniorGain;
+    if (gain > 0n) {
+      if (tranche.junior.totalSupply > 0n) tranche.junior.value += gain;
+      else tranche.senior.value += gain;
+    }
+  } else {
+    const loss = before - after;
+    const juniorLoss = tranche.junior.value < loss ? tranche.junior.value : loss;
+    tranche.junior.value -= juniorLoss;
+    tranche.senior.value -= loss - juniorLoss;
+  }
+  refreshShareClass(tranche.junior);
+  refreshShareClass(tranche.senior);
+  tranche.lastSettledTs = nowTs;
+  return nextTvl - tranche.junior.value - tranche.senior.value;
+}
+function seniorEntitlement(tranche, nowTs) {
+  if (tranche.seniorApyAnchorTs <= 0n) {
+    tranche.seniorApyAnchorSharePrice = tranche.senior.sharePrice;
+    tranche.seniorApyAnchorTs = tranche.lastSettledTs > 0n ? tranche.lastSettledTs : nowTs;
+  }
+  if (tranche.seniorFixedApyBps === 0 || tranche.seniorApyAnchorSharePrice === 0n || tranche.senior.totalSupply === 0n || tranche.seniorApyAnchorTs <= 0n || nowTs <= tranche.seniorApyAnchorTs) {
+    return 0n;
+  }
+  const targetPrice = applyEffectiveApy(
+    tranche.seniorApyAnchorSharePrice,
+    tranche.seniorFixedApyBps,
+    nowTs - tranche.seniorApyAnchorTs
+  );
+  const targetValue = mulDiv2(
+    targetPrice,
+    tranche.senior.totalSupply,
+    DEFAULT_SHARE_PRICE
+  );
+  return targetValue > tranche.senior.value ? targetValue - tranche.senior.value : 0n;
+}
+function settleShareClassPerformanceFee(shareClass, performanceFeeBps, protocolFeeBps) {
+  refreshShareClass(shareClass);
+  const grossPrice = shareClass.sharePrice;
+  if (shareClass.hwmSharePrice === 0n) {
+    shareClass.hwmSharePrice = grossPrice;
+    return noFees();
+  }
+  if (performanceFeeBps + protocolFeeBps === 0 || shareClass.totalSupply === 0n || grossPrice <= shareClass.hwmSharePrice) {
+    return noFees();
+  }
+  const gainValue = mulDiv2(
+    grossPrice - shareClass.hwmSharePrice,
+    shareClass.totalSupply,
+    DEFAULT_SHARE_PRICE
+  );
+  const fees = feeAmounts(gainValue, performanceFeeBps, protocolFeeBps);
+  const total = fees.curator + fees.protocol;
+  if (total > 0n) {
+    shareClass.value -= total;
+    refreshShareClass(shareClass);
+    shareClass.hwmSharePrice = shareClass.sharePrice;
+  }
+  return fees;
+}
+function settleRegularPerformanceFee(grossValue, supply, hwmSharePrice, performanceFeeBps, protocolFeeBps) {
+  if (supply === 0n) return { netValue: grossValue, fees: noFees() };
+  const grossPrice = sharePriceForValue(grossValue, supply);
+  if (hwmSharePrice === 0n || grossPrice <= hwmSharePrice || performanceFeeBps + protocolFeeBps === 0) {
+    return { netValue: grossValue, fees: noFees() };
+  }
+  const gainValue = mulDiv2(
+    supply,
+    grossPrice - hwmSharePrice,
+    DEFAULT_SHARE_PRICE
+  );
+  const fees = feeAmounts(gainValue, performanceFeeBps, protocolFeeBps);
+  return {
+    netValue: grossValue - fees.curator - fees.protocol,
+    fees
+  };
+}
+function settleFixedApyNav(args) {
+  if (args.fixedApyBps === 0 || args.currentSharePrice === 0n || args.totalSupply === 0n || args.anchorSharePrice === 0n || args.anchorTs <= 0n) {
+    return args.reportedNav;
+  }
+  if (args.nowTs <= args.anchorTs) {
+    const anchoredNav = mulDiv2(
+      args.totalSupply,
+      args.anchorSharePrice,
+      DEFAULT_SHARE_PRICE
+    );
+    if (args.reportedNav !== anchoredNav) {
+      throw new Error("crank would fail InvalidOracleUpdate at APY anchor");
+    }
+    return args.reportedNav;
+  }
+  const fixedPrice = applyEffectiveApy(
+    args.anchorSharePrice,
+    args.fixedApyBps,
+    args.nowTs - args.anchorTs
+  );
+  const fixedNav = mulDiv2(args.totalSupply, fixedPrice, DEFAULT_SHARE_PRICE);
+  return args.reportedNav >= fixedNav ? fixedNav : args.reportedNav;
+}
+function validateRealizedApy(priorValue, priorTs, nextValue, nextTs, maxApyBps) {
+  if (maxApyBps === 0 || priorValue === 0n || priorTs <= 0n || nextValue <= priorValue) {
+    return;
+  }
+  const elapsed = nextTs - priorTs;
+  if (elapsed <= 0n) throw new Error("crank would fail MaxApyExceeded");
+  const lhs = (nextValue - priorValue) * BPS_DENOMINATOR2 * SECONDS_PER_YEAR;
+  const rhs = BigInt(maxApyBps) * priorValue * elapsed;
+  if (lhs > rhs) {
+    const implied = lhs / (priorValue * elapsed);
+    throw new Error(
+      `crank would fail MaxApyExceeded: implied ${implied}bps > ${maxApyBps}bps`
+    );
+  }
+}
+function grossNavFromHoldings(holdings, nowTs, stalenessSecs) {
+  let nav = 0n;
+  for (const holding of holdings) {
+    if (holding.cleared) continue;
+    const amount = holding.localAmount + holding.externalAmount;
+    if (amount === 0n && !holding.isBase) continue;
+    if (holding.price <= 0n) {
+      throw new Error(`crank blocked: holding ${holding.mint} is unpriced`);
+    }
+    if (holding.priceOracleType !== "none" && (holding.lastUpdateTs <= 0n || nowTs - holding.lastUpdateTs < 0n || nowTs - holding.lastUpdateTs > stalenessSecs)) {
+      throw new Error(
+        `crank blocked: holding ${holding.mint} price is stale (ts=${holding.lastUpdateTs})`
+      );
+    }
+    if (amount > 0n) {
+      nav += mulDiv2(amount, holding.price, 10n ** BigInt(holding.decimals));
+    }
+  }
+  return nav;
+}
+function decodeOracleData(data, nowTs) {
+  if (data.length < ENTRIES_OFFSET + MAX_SIGNERS * ENTRY_SIZE) {
+    throw new Error(`oracle payload is too short (${data.length} bytes)`);
+  }
+  const entries = [];
+  for (let signerIndex = 0; signerIndex < MAX_SIGNERS; signerIndex += 1) {
+    const offset = ENTRIES_OFFSET + signerIndex * ENTRY_SIZE;
+    const signerBytes = new Uint8Array(data.slice(offset, offset + 32));
+    const prices = Array.from(
+      { length: MAX_HOLDINGS },
+      (_, holdingIndex) => readU64(data, offset + PRICE_OFFSET + holdingIndex * 8)
+    );
+    const externalAmounts = Array.from(
+      { length: MAX_HOLDINGS },
+      (_, holdingIndex) => readU64(data, offset + EXTERNAL_OFFSET + holdingIndex * 8)
+    );
+    entries.push({
+      signer: new import_web326.PublicKey(signerBytes).toBase58(),
+      lastUpdateTs: readI64(data, offset + 32),
+      prices,
+      externalAmounts
+    });
+  }
+  const pendingOffset = ENTRIES_OFFSET + MAX_SIGNERS * ENTRY_SIZE;
+  const pendingEffectiveTs = readI64(data, pendingOffset + 128);
+  const pendingCount = data[pendingOffset + 136] ?? 0;
+  if (pendingCount > 0 && pendingCount <= MAX_SIGNERS && nowTs >= pendingEffectiveTs) {
+    for (let index = 0; index < MAX_SIGNERS; index += 1) {
+      const signerBytes = new Uint8Array(
+        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(),
+        lastUpdateTs: 0n,
+        prices: Array(MAX_HOLDINGS).fill(0n),
+        externalAmounts: Array(MAX_HOLDINGS).fill(0n)
+      };
+    }
+  }
+  return {
+    settledNavTs: readI64(data, 8),
+    stalenessThresholdSecs: positiveOrDefault(
+      readI64(data, 32),
+      DEFAULT_STALENESS_SECS
+    ),
+    entries
+  };
+}
+function decodeHolding(value) {
+  const holding = record(value);
+  const mintString = pubkeyString3(holding.mint);
+  return {
+    mint: (0, import_kit14.address)(mintString),
+    decimals: number(holding.decimals),
+    priceOracleType: variant(holding.priceOracleType),
+    isBase: bool(holding.isBase),
+    localAmount: bigint(holding.localAmount),
+    externalAmount: bigint(holding.externalAmount),
+    price: bigint(holding.price),
+    lastUpdateTs: bigint(holding.lastUpdateTs),
+    cleared: mintString === import_web326.PublicKey.default.toBase58()
+  };
+}
+function decodeTrancheState(decoded, args, warnings, blockers) {
+  if (!decoded) {
+    blockers.push("tranching is enabled but the tranche state was unavailable");
+    return void 0;
+  }
+  const junior = decodeShareClass(decoded.junior);
+  const senior = decodeShareClass(decoded.senior);
+  if (args.physicalJuniorSupply === void 0) {
+    warnings.push(
+      "junior mint supply unavailable; using cached tranche supply"
+    );
+  } else {
+    junior.totalSupply = args.physicalJuniorSupply;
+    refreshShareClass(junior);
+  }
+  if (args.physicalSeniorSupply === void 0) {
+    warnings.push(
+      "senior mint supply unavailable; using cached tranche supply"
+    );
+  } else {
+    senior.totalSupply = args.physicalSeniorSupply;
+    refreshShareClass(senior);
+  }
+  return {
+    junior,
+    senior,
+    seniorFixedApyBps: number(decoded.config.seniorFixedApyBps),
+    lastSettledTs: bigint(decoded.lastSettledTs),
+    seniorApyAnchorSharePrice: bigint(decoded.seniorApyAnchorSharePrice),
+    seniorApyAnchorTs: bigint(decoded.seniorApyAnchorTs)
+  };
+}
+function decodeShareClass(value) {
+  const decoded = record(value);
+  return {
+    value: bigint(decoded.value),
+    totalSupply: bigint(decoded.totalSupply),
+    sharePrice: bigint(decoded.sharePrice),
+    hwmSharePrice: bigint(decoded.hwmSharePrice)
+  };
+}
+function snapshot(tvl, regularSupply, regularSharePrice, tranche) {
+  const regularValue = mulDiv2(
+    regularSupply,
+    regularSharePrice,
+    DEFAULT_SHARE_PRICE
+  );
+  return {
+    tvl,
+    regular: {
+      value: regularValue,
+      totalSupply: regularSupply,
+      sharePrice: regularSharePrice
+    },
+    ...tranche ? {
+      junior: publicShareClass(tranche.junior),
+      senior: publicShareClass(tranche.senior)
+    } : {}
+  };
+}
+function publicShareClass(value) {
+  return {
+    value: value.value,
+    totalSupply: value.totalSupply,
+    sharePrice: value.sharePrice
+  };
+}
+function refreshShareClass(value) {
+  value.sharePrice = value.totalSupply === 0n ? DEFAULT_SHARE_PRICE : mulDiv2(value.value, DEFAULT_SHARE_PRICE, value.totalSupply);
+}
+function sharePriceForValue(value, supply) {
+  return supply === 0n ? void 0 : mulDiv2(value, DEFAULT_SHARE_PRICE, supply);
+}
+function feeAmounts(value, performanceFeeBps, protocolFeeBps) {
+  return {
+    curator: mulDiv2(value, BigInt(performanceFeeBps), BPS_DENOMINATOR2),
+    protocol: mulDiv2(value, BigInt(protocolFeeBps), BPS_DENOMINATOR2)
+  };
+}
+function noFees() {
+  return { curator: 0n, protocol: 0n };
+}
+function withinDeviation(values) {
+  for (let i = 0; i < values.length; i += 1) {
+    for (let j = i + 1; j < values.length; j += 1) {
+      const a = values[i];
+      const b = values[j];
+      if (a === b) continue;
+      if (a === 0n || b === 0n) return false;
+      const diff = abs(a * BPS_DENOMINATOR2 / b - BPS_DENOMINATOR2);
+      if (diff > CONSENSUS_MAX_DIFF_BPS) return false;
+    }
+  }
+  return true;
+}
+function average(values) {
+  return values.reduce((sum, value) => sum + value, 0n) / BigInt(values.length);
+}
+function isFresh(lastTs, nowTs, staleness) {
+  if (lastTs <= 0n) return false;
+  const age = nowTs - lastTs;
+  return age >= 0n && age <= staleness;
+}
+function applyEffectiveApy(anchor, apyBps, elapsedSecs) {
+  if (anchor === 0n || apyBps === 0 || elapsedSecs === 0n) return anchor;
+  if (apyBps < 0 || apyBps > 1e4) throw new Error("invalid APY bps");
+  const base = APY_SCALE + mulDiv2(BigInt(apyBps), APY_SCALE, BPS_DENOMINATOR2);
+  const wholeYears = elapsedSecs / SECONDS_PER_YEAR;
+  const remainder = elapsedSecs % SECONDS_PER_YEAR;
+  const wholeMultiplier = fixedPointPow(base, wholeYears);
+  const fractionalMultiplier = remainder === 0n ? APY_SCALE : fixedPointExp(
+    mulDiv2(
+      fixedPointLnBetweenOneAndTwo(base),
+      remainder,
+      SECONDS_PER_YEAR
+    )
+  );
+  return mulDiv2(
+    anchor,
+    fixedPointMul(wholeMultiplier, fractionalMultiplier),
+    APY_SCALE
+  );
+}
+function fixedPointMul(lhs, rhs) {
+  const lhsWhole = lhs / APY_SCALE;
+  const lhsRemainder = lhs % APY_SCALE;
+  const rhsWhole = rhs / APY_SCALE;
+  const rhsRemainder = rhs % APY_SCALE;
+  return lhsWhole * rhs + lhsRemainder * rhsWhole + lhsRemainder * rhsRemainder / APY_SCALE;
+}
+function fixedPointPow(baseInput, exponentInput) {
+  let base = baseInput;
+  let exponent = exponentInput;
+  let result = APY_SCALE;
+  while (exponent > 0n) {
+    if ((exponent & 1n) === 1n) result = fixedPointMul(result, base);
+    exponent >>= 1n;
+    if (exponent > 0n) base = fixedPointMul(base, base);
+  }
+  return result;
+}
+function fixedPointLnBetweenOneAndTwo(value) {
+  if (value < APY_SCALE || value > 2n * APY_SCALE) {
+    throw new Error("APY logarithm input out of range");
+  }
+  const z = mulDiv2(value - APY_SCALE, APY_SCALE, value + APY_SCALE);
+  const zSquared = fixedPointMul(z, z);
+  let power = z;
+  let sum = 0n;
+  for (let index = 0; index < APY_SERIES_TERMS; index += 1) {
+    sum += power / BigInt(2 * index + 1);
+    power = fixedPointMul(power, zSquared);
+  }
+  return sum * 2n;
+}
+function fixedPointExp(value) {
+  if (value > APY_LN_2) throw new Error("APY exponent input out of range");
+  let sum = APY_SCALE;
+  let term = APY_SCALE;
+  for (let divisor = 1; divisor <= APY_SERIES_TERMS; divisor += 1) {
+    term = fixedPointMul(term, value) / BigInt(divisor);
+    if (term === 0n) break;
+    sum += term;
+  }
+  return sum;
+}
+function readU64(data, offset) {
+  let value = 0n;
+  for (let index = 0; index < 8; index += 1) {
+    value |= BigInt(data[offset + index] ?? 0) << BigInt(index * 8);
+  }
+  return value;
+}
+function readI64(data, offset) {
+  const value = readU64(data, offset);
+  return value >= 0x8000000000000000n ? value - 0x10000000000000000n : value;
+}
+function mulDiv2(a, b, c) {
+  if (c === 0n) throw new Error("division by zero in settlement simulation");
+  return a * b / c;
+}
+function record(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function bigint(value) {
+  if (value === void 0 || value === null) return 0n;
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" || typeof value === "string") {
+    return BigInt(value);
+  }
+  return BigInt(String(value));
+}
+function number(value) {
+  return Number(bigint(value));
+}
+function bool(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (value && typeof value.toBool === "function") {
+    return value.toBool();
+  }
+  const pod = value;
+  return Boolean(pod?.value ?? pod?.[0]);
+}
+function variant(value) {
+  return (value && typeof value === "object" ? Object.keys(value)[0] ?? "" : String(value ?? "")).toLowerCase();
+}
+function pubkeyString3(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value.toBase58 === "function") {
+    return value.toBase58();
+  }
+  return String(value);
+}
+function positiveOrDefault(value, fallback) {
+  return value > 0n ? value : fallback;
+}
+function max(a, b) {
+  return a > b ? a : b;
+}
+function abs(value) {
+  return value < 0n ? -value : value;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function formatSettlementSimulation(simulation) {
+  const lines = [];
+  lines.push(
+    `  proposed oracle values: ${simulation.allProposedUpdatesLand ? "WOULD REACH CONSENSUS" : "WOULD NOT ALL LAND"} (${simulation.proposedUpdatesLanded}/${simulation.proposedUpdatesTotal} holdings)`
+  );
+  lines.push(
+    `  crank simulation: ${simulation.canSettle ? "WOULD SETTLE" : "BLOCKED"}`
+  );
+  for (const holding of simulation.consensus) {
+    const detail = holding.settledPrice ? `price=${holding.settledPrice} external=${holding.settledExternalAmount}` : holding.reason ?? "no aggregate";
+    lines.push(
+      `    consensus #${holding.holdingIndex} ${holding.mint}: ${holding.reportCount} report(s), ${holding.wouldUpdateHolding ? "lands" : "unchanged"} (${detail})`
+    );
+  }
+  if (simulation.grossNav !== void 0) {
+    lines.push(
+      `    gross NAV: ${formatUnits(
+        simulation.grossNav,
+        simulation.assetDecimals
+      )} [${simulation.grossNav}]`
+    );
+  }
+  if (simulation.settledAccountingNav !== void 0 && simulation.settledAccountingNav !== simulation.grossNav) {
+    lines.push(
+      `    accounting NAV after fixed APY: ${formatUnits(
+        simulation.settledAccountingNav,
+        simulation.assetDecimals
+      )} [${simulation.settledAccountingNav}]`
+    );
+  }
+  if (simulation.projected) {
+    lines.push(
+      `    TVL:       ${formatTransition(
+        simulation.current.tvl,
+        simulation.projected.tvl,
+        simulation.assetDecimals
+      )}`
+    );
+    lines.push(
+      `    regular:   ${formatTransition(
+        simulation.current.regular.sharePrice,
+        simulation.projected.regular.sharePrice,
+        6
+      )} per share`
+    );
+    lines.push(
+      `               supply ${simulation.current.regular.totalSupply} -> ${simulation.projected.regular.totalSupply}, backing ${simulation.current.regular.value} -> ${simulation.projected.regular.value}`
+    );
+    if (simulation.current.junior && simulation.projected.junior) {
+      lines.push(
+        `    junior:    ${formatTransition(
+          simulation.current.junior.sharePrice,
+          simulation.projected.junior.sharePrice,
+          6
+        )} per share`
+      );
+      lines.push(
+        `               supply ${simulation.current.junior.totalSupply} -> ${simulation.projected.junior.totalSupply}, value ${simulation.current.junior.value} -> ${simulation.projected.junior.value}`
+      );
+    }
+    if (simulation.current.senior && simulation.projected.senior) {
+      lines.push(
+        `    senior:    ${formatTransition(
+          simulation.current.senior.sharePrice,
+          simulation.projected.senior.sharePrice,
+          6
+        )} per share`
+      );
+      lines.push(
+        `               supply ${simulation.current.senior.totalSupply} -> ${simulation.projected.senior.totalSupply}, value ${simulation.current.senior.value} -> ${simulation.projected.senior.value}`
+      );
+    }
+  }
+  if (simulation.performanceFees) {
+    lines.push(
+      `    performance fees: curator=${simulation.performanceFees.curator} protocol=${simulation.performanceFees.protocol} total=${simulation.performanceFees.total} fee_shares=${simulation.performanceFees.mintedShares}`
+    );
+  }
+  for (const blocker of simulation.blockers)
+    lines.push(`    BLOCKER: ${blocker}`);
+  for (const warning of simulation.warnings)
+    lines.push(`    warning: ${warning}`);
+  return lines;
+}
+function formatTransition(before, after, decimals) {
+  return `${formatUnits(before, decimals)} [${before}] -> ${formatUnits(
+    after,
+    decimals
+  )} [${after}]`;
+}
+function formatUnits(value, decimals) {
+  const negative = value < 0n;
+  const absolute = negative ? -value : value;
+  const scale = 10n ** BigInt(decimals);
+  const whole = absolute / scale;
+  const fraction = (absolute % scale).toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${negative ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
+}
+
+// src/services/consensusOracle/consensusOracleService.ts
 var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
 var CONSENSUS_ORACLE_VARIANT = "consensusoracle";
 function variantName2(value) {
@@ -19444,8 +20486,8 @@ function variantName2(value) {
 function coerceBool3(value) {
   if (typeof value === "boolean") return value;
   if (typeof value === "number") return value !== 0;
-  const record = value;
-  return Boolean(record?.value ?? record?.[0]);
+  const record2 = value;
+  return Boolean(record2?.value ?? record2?.[0]);
 }
 function priceInAccountingUnit(usd, baseUsd, assetDecimals) {
   return BigInt(Math.round(usd / baseUsd * 10 ** assetDecimals));
@@ -19467,7 +20509,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: "",
@@ -19492,22 +20534,60 @@ var ConsensusOracleService = class {
     });
     const dryRun = opts.dryRun ?? false;
     const vaultState = await this.fetchDecodedVault(target.vault);
-    const consensusHoldings = selectConsensusHoldings(vaultState.holdings);
+    const receiptMints = await this.fetchReceiptMints(target.vault, vaultState);
+    const consensusHoldings = selectConsensusHoldings(
+      vaultState.holdings,
+      receiptMints
+    );
+    const filteredCount = vaultState.holdings.filter(
+      (holding) => receiptMints.has((0, import_common41.fromWeb3Pk)(holding.mint).toString())
+    ).length;
+    if (filteredCount > 0) {
+      log(
+        `vault ${target.vault}: excluded ${filteredCount} vault/tranche receipt mint holding(s)`
+      );
+    }
     if (consensusHoldings.length === 0) {
       log(`vault ${target.vault}: no consensus holdings, skipping`);
       return { vault: target.vault, updates: [], dryRun };
     }
+    const filteredTarget = filterTargetHoldings(target, receiptMints);
+    await this.assertNoUnconfirmedYieldPayments(filteredTarget);
     const inputs = await this.gatherPricingInputs(
-      target,
+      filteredTarget,
       vaultState,
       consensusHoldings
     );
     const updates = await this.buildUpdates(consensusHoldings, inputs);
     if (dryRun) {
       log(`vault ${target.vault}: dry run, ${updates.length} holding(s)`);
-      return { vault: target.vault, updates, dryRun: true };
+      try {
+        const settlementSimulation = await this.simulateDryRunSettlement(
+          signer,
+          target.vault,
+          vaultState,
+          updates
+        );
+        return {
+          vault: target.vault,
+          updates,
+          dryRun: true,
+          settlementSimulation
+        };
+      } catch (error) {
+        const settlementSimulationError = error instanceof Error ? error.message : String(error);
+        log(
+          `vault ${target.vault}: settlement simulation unavailable: ${settlementSimulationError}`
+        );
+        return {
+          vault: target.vault,
+          updates,
+          dryRun: true,
+          settlementSimulationError
+        };
+      }
     }
-    const { updateSignature, crankSignature, crankSkippedReason } = await this.settleVault(signer, target.vault, updates, vaultState, log);
+    const { updateSignature, crankSignature, crankSkippedReason } = await this.settleVault(signer, filteredTarget, updates, vaultState, log);
     return {
       vault: target.vault,
       updates,
@@ -19517,6 +20597,76 @@ var ConsensusOracleService = class {
       crankSkippedReason
     };
   }
+  /** Read canonical supplies and replay the exact on-chain settlement path. */
+  async simulateDryRunSettlement(signer, vault, vaultState, updates) {
+    const tranchingEnabled = coerceBool3(vaultState.tranchingEnabled);
+    const [oracleState, trancheState] = await Promise.all([
+      this.client.account.fetchVaultOracleForVault(vault, { fresh: true }),
+      tranchingEnabled ? this.client.account.fetchVaultTrancheStateForVault(vault, {
+        fresh: true
+      }) : Promise.resolve(void 0)
+    ]);
+    const mintKeys = [new import_web327.PublicKey(vaultState.mint)];
+    if (trancheState) {
+      mintKeys.push(
+        new import_web327.PublicKey(trancheState.config.juniorMint),
+        new import_web327.PublicKey(trancheState.config.seniorMint)
+      );
+    }
+    const mintAccounts = await this.client.provider.connection.getMultipleAccountsInfo(
+      mintKeys,
+      "confirmed"
+    );
+    const supplies = mintAccounts.map((info, index) => {
+      if (!info)
+        throw new Error(`share mint ${mintKeys[index]} does not exist`);
+      return readSplMintSupply(info.data);
+    });
+    return simulateConsensusOracleSettlement({
+      vault: vaultState,
+      oracleData: oracleState.data,
+      trancheState,
+      updates,
+      signer: (0, import_common41.fromWeb3Pk)(signer.publicKey),
+      nowTs: BigInt(Math.floor(this.clock.now() / 1e3)),
+      physicalShareSupply: supplies[0],
+      physicalJuniorSupply: tranchingEnabled ? supplies[1] : void 0,
+      physicalSeniorSupply: tranchingEnabled ? supplies[2] : void 0
+    });
+  }
+  /**
+   * 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).
@@ -19605,6 +20755,28 @@ var ConsensusOracleService = class {
       fresh: true
     });
   }
+  /**
+   * Receipt mints issued by this vault are liabilities/shares, not underlying
+   * assets for its own NAV. Exclude them even if they were registered as
+   * consensus-priced holdings.
+   */
+  async fetchReceiptMints(vault, vaultState) {
+    const receiptMints = /* @__PURE__ */ new Set();
+    if (vaultState.mint) {
+      receiptMints.add((0, import_common41.fromWeb3Pk)(vaultState.mint).toString());
+    }
+    if (!coerceBool3(vaultState.tranchingEnabled)) return receiptMints;
+    const trancheState = await this.client.account.fetchVaultTrancheStateForVault(vault, {
+      fresh: true
+    });
+    receiptMints.add(
+      (0, import_common41.fromWeb3Pk)(trancheState.config.juniorMint).toString()
+    );
+    receiptMints.add(
+      (0, import_common41.fromWeb3Pk)(trancheState.config.seniorMint).toString()
+    );
+    return receiptMints;
+  }
   /** Fetch every external input the per-holding updates draw on, in parallel-ish. */
   async gatherPricingInputs(target, vaultState, consensusHoldings) {
     const manager = (0, import_common41.fromWeb3Pk)(vaultState.roles.manager);
@@ -19714,7 +20886,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)`
     );
@@ -19724,6 +20897,7 @@ var ConsensusOracleService = class {
       );
     }
     await this.logProspectiveApy(vault, updates, vaultState, log);
+    await this.assertNoUnconfirmedYieldPayments(target);
     const updateSignature = await this.oracle.updateAssetConsensusPrice(
       signer,
       {
@@ -19774,8 +20948,8 @@ var ConsensusOracleService = class {
       const nowSecs = BigInt(Math.floor(this.clock.now() / 1e3));
       const elapsedSecs = nowSecs - settledNavTs;
       if (elapsedSecs <= 0n) return;
-      const SECONDS_PER_YEAR2 = 365n * 24n * 3600n;
-      const apyBps = (prospectiveNav - settledNav) * SECONDS_PER_YEAR2 * 10000n / (settledNav * elapsedSecs);
+      const SECONDS_PER_YEAR3 = 365n * 24n * 3600n;
+      const apyBps = (prospectiveNav - settledNav) * SECONDS_PER_YEAR3 * 10000n / (settledNav * elapsedSecs);
       log(
         `vault ${vault}: prospective NAV ${prospectiveNav} vs settled ${settledNav} (elapsed ${elapsedSecs}s) \u2192 implied APY ${apyBps}bps`
       );
@@ -19791,13 +20965,23 @@ function readI64LE(data, offset) {
   if (value >= 0x8000000000000000n) value -= 0x10000000000000000n;
   return value;
 }
-var ENTRY_SIZE = 272;
-var ENTRIES_OFFSET = 40;
+function readSplMintSupply(data) {
+  if (data.length < 44) {
+    throw new Error(`invalid SPL mint account: expected at least 44 bytes`);
+  }
+  let supply = 0n;
+  for (let i = 0; i < 8; i += 1) {
+    supply |= BigInt(data[36 + i]) << BigInt(8 * i);
+  }
+  return supply;
+}
+var ENTRY_SIZE2 = 272;
+var ENTRIES_OFFSET2 = 40;
 var MAX_CONSENSUS_SIGNERS = 4;
 function signerInOracleData(data, signerBytes) {
   const ZERO_PUBKEY = new Uint8Array(32);
   for (let i = 0; i < MAX_CONSENSUS_SIGNERS; i++) {
-    const off = ENTRIES_OFFSET + i * ENTRY_SIZE;
+    const off = ENTRIES_OFFSET2 + i * ENTRY_SIZE2;
     const slice = data.slice(off, off + 32);
     if (slice.length < 32) break;
     const bytes = new Uint8Array(slice);
@@ -19807,12 +20991,21 @@ function signerInOracleData(data, signerBytes) {
   }
   return false;
 }
-function selectConsensusHoldings(holdings) {
+function selectConsensusHoldings(holdings, excludedMints = /* @__PURE__ */ new Set()) {
   return holdings.map((holding, holdingIndex) => ({ holding, holdingIndex })).filter(({ holding }) => {
     const mint = (0, import_common41.fromWeb3Pk)(holding.mint);
-    return mint !== SYSTEM_PROGRAM2 && variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT;
+    return mint !== SYSTEM_PROGRAM2 && !excludedMints.has(mint.toString()) && variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT;
   });
 }
+function filterTargetHoldings(target, excludedMints) {
+  if (!target.holdings?.length || excludedMints.size === 0) return target;
+  return {
+    ...target,
+    holdings: target.holdings.filter(
+      (holding) => !excludedMints.has(holding.mint.toString())
+    )
+  };
+}
 
 // src/services/consensusOracle/runLiveConsensusOracle.ts
 async function runLiveConsensusOracle(env, oracleSigner, opts = {}) {
@@ -19836,7 +21029,7 @@ async function runLiveConsensusOracle(env, oracleSigner, opts = {}) {
 }
 
 // src/services/consensusOracle/mockYieldTracker.ts
-var SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+var SECONDS_PER_YEAR2 = 365 * 24 * 60 * 60;
 var MockYieldTracker = class {
   constructor(opts = {}) {
     this.accounts = /* @__PURE__ */ new Map();
@@ -19868,6 +21061,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(
@@ -19885,12 +21084,12 @@ var MockYieldTracker = class {
     let segStart = windowStartMs;
     for (const cf of boundaries) {
       const dtSecs = (cf.ts - segStart) / 1e3;
-      totalYield += principal * apr * (dtSecs / SECONDS_PER_YEAR);
+      totalYield += principal * apr * (dtSecs / SECONDS_PER_YEAR2);
       principal += cf.amount;
       segStart = cf.ts;
     }
     const tailSecs = Math.max(0, (windowEndMs - segStart) / 1e3);
-    totalYield += principal * apr * (tailSecs / SECONDS_PER_YEAR);
+    totalYield += principal * apr * (tailSecs / SECONDS_PER_YEAR2);
     const paidYield = state.yieldPayments.reduce((sum, payment) => {
       return payment.status === "confirmed" && payment.effectiveAt > windowStartMs && payment.effectiveAt <= windowEndMs ? sum + payment.amount : sum;
     }, 0);
@@ -19910,22 +21109,22 @@ var MockYieldTracker = class {
   async getTotalYield(accountNames, start, end) {
     let total = 0;
     for (const name of accountNames) {
-      const snapshot = await this.getYield(name, start, end);
-      total += snapshot.totalYield;
+      const snapshot2 = await this.getYield(name, start, end);
+      total += snapshot2.totalYield;
     }
     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;
+      const snapshot2 = await this.getYield(name, start, end);
+      total += snapshot2.outstandingYield;
     }
     return total;
   }
   async getBalance(accountName, atTime) {
-    const snapshot = await this.getYield(accountName, void 0, atTime);
-    return snapshot.principalAtEnd + snapshot.outstandingYield;
+    const snapshot2 = await this.getYield(accountName, void 0, atTime);
+    return snapshot2.principalAtEnd + snapshot2.outstandingYield;
   }
   async addCashflow(params) {
     const state = this.require(params.accountName);
@@ -19977,12 +21176,12 @@ var MockYieldTracker = class {
     let cumulativePaid = 0;
     for (const candidate of chronologicalPayments) {
       cumulativePaid += candidate.amount;
-      const snapshot = await this.getYield(
+      const snapshot2 = await this.getYield(
         params.accountName,
         void 0,
         new Date(candidate.effectiveAt)
       );
-      if (cumulativePaid > snapshot.totalYield + 1e-9) {
+      if (cumulativePaid > snapshot2.totalYield + 1e-9) {
         throw new Error("Confirmed payment exceeds accrued unpaid yield");
       }
     }
@@ -19992,8 +21191,8 @@ var MockYieldTracker = class {
 };
 
 // src/services/externalLiquidityIntegrityService.ts
-var import_kit13 = require("@solana/kit");
-var import_web326 = require("@solana/web3.js");
+var import_kit15 = require("@solana/kit");
+var import_web328 = require("@solana/web3.js");
 var import_common42 = __toESM(require_dist());
 var import_marginfi2 = __toESM(require_dist2());
 function parseActiveSlots(externalLiquidity) {
@@ -20006,7 +21205,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_web328.PublicKey(pubkeyBytes));
     results.push({ index: i, source: "marginfi", userAccount });
   }
   return results;
@@ -20072,7 +21271,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_web328.PublicKey(vault.toString());
     const registeredHwManager = pubkeyStr(
       vaultState.roles.hwManager
     );
@@ -20099,7 +21298,7 @@ var ExternalLiquidityIntegrityService = class {
         continue;
       }
       for (const holding of holdings) {
-        const mintAddress = (0, import_kit13.address)(pubkeyStr(holding.mint));
+        const mintAddress = (0, import_kit15.address)(pubkeyStr(holding.mint));
         const localAmount = toBigInt2(holding.localAmount);
         const marginfiAccounts = (0, import_marginfi2.marginfiAccountsForMint)(mintAddress);
         if (!marginfiAccounts) {
@@ -20215,11 +21414,17 @@ var ExternalLiquidityIntegrityService = class {
   JupiterPriceSource,
   JupiterSwapBuilder,
   KaminoPositionProvider,
+  LOCAL_PROTOCOL_ADMIN,
+  LivePriceSource,
   MAX_PRICE_STALENESS_THRESHOLD_SECS,
   ManagerRedepositAssetBuilder,
   ManagerWithdrawAssetBuilder,
   MarginfiPositionProvider,
   MockYieldTracker,
+  NEST_API_BASE_URL,
+  NEST_RWA_SHARE_MINT,
+  NEST_VAULT_SLUG,
+  NestPriceSource,
   OracleService,
   PROGRAM_FEE_EXEMPT_OWNER_WHITELIST,
   PROTOCOL_ADMIN,
@@ -20262,6 +21467,7 @@ var ExternalLiquidityIntegrityService = class {
   WithdrawalQueueService,
   addCashflowUpdate,
   address,
+  applyEffectiveApy,
   confirmYieldPayment,
   createAccount,
   createLiveConsensusOracleDeps,
@@ -20273,6 +21479,9 @@ var ExternalLiquidityIntegrityService = class {
   dateToStr,
   defaultKeypairPath,
   deleteAccount,
+  fetchNestTokenPrice,
+  findSquadsWalletRoute,
+  formatSettlementSimulation,
   fromUiAmount,
   getAccounts,
   getBalance,
@@ -20288,11 +21497,16 @@ var ExternalLiquidityIntegrityService = class {
   loadKeypair,
   makeProvider,
   mintTokensTo,
+  prepareVaultTransaction,
   resolveKeypairPath,
+  resolveSquadsWalletRoute,
   roundToNextUtcMidnight,
   runLiveConsensusOracle,
+  simulateConsensusOracleSettlement,
   systemClock,
   toUiAmount,
   updateAccount,
-  updateDynamicApr
+  updateDynamicApr,
+  validateSquadsWalletRoutes,
+  vaultAuthorityForWallet
 });