@perena/vault-sdk 1.0.23 → 1.0.24

package/dist/index.js

@@ -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);
@@ -611,12 +611,12 @@ var require_transaction = __commonJS({
     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: 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) {
@@ -1290,7 +1290,7 @@ var require_cpiClient = __commonJS({
         });
         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,
@@ -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,7 +1479,9 @@ __export(index_exports, {
   dateToStr: () => dateToStr,
   defaultKeypairPath: () => defaultKeypairPath,
   deleteAccount: () => deleteAccount,
+  fetchNestTokenPrice: () => fetchNestTokenPrice,
   findSquadsWalletRoute: () => findSquadsWalletRoute,
+  formatSettlementSimulation: () => formatSettlementSimulation,
   fromUiAmount: () => fromUiAmount,
   getAccounts: () => getAccounts,
   getBalance: () => getBalance,
@@ -1493,6 +1502,7 @@ __export(index_exports, {
   resolveSquadsWalletRoute: () => resolveSquadsWalletRoute,
   roundToNextUtcMidnight: () => roundToNextUtcMidnight,
   runLiveConsensusOracle: () => runLiveConsensusOracle,
+  simulateConsensusOracleSettlement: () => simulateConsensusOracleSettlement,
   systemClock: () => systemClock,
   toUiAmount: () => toUiAmount,
   updateAccount: () => updateAccount,
@@ -1511,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)(
@@ -1522,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()
@@ -1768,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."
           ]
         },
         {
@@ -1832,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
         },
@@ -1926,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": [
@@ -2013,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": {
@@ -2063,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": [
@@ -2073,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": {
@@ -2120,7 +2066,7 @@ var IDL = {
           }
         },
         {
-          "name": "fee_asset_token_program"
+          "name": "share_token_program"
         },
         {
           "name": "associated_token_program",
@@ -3003,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."
@@ -3227,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
         },
@@ -3522,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
         },
@@ -4018,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
         },
@@ -4320,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
         },
@@ -5111,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
         },
@@ -5400,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
         },
@@ -5695,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
         },
@@ -6000,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
         },
@@ -7422,9 +7370,6 @@ var IDL = {
         },
         {
           "name": "idle_bank_tranche",
-          "docs": [
-            "path rejects initialized state because it cannot represent junior claims."
-          ],
           "pda": {
             "seeds": [
               {
@@ -7583,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": [
@@ -7761,9 +7706,6 @@ var IDL = {
         },
         {
           "name": "vault_tranche_state",
-          "docs": [
-            "be initialized and consistent with destination.tranching_enabled."
-          ],
           "writable": true,
           "pda": {
             "seeds": [
@@ -9787,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": [
@@ -10548,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
         },
@@ -11866,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": {
@@ -12105,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"
@@ -13410,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": {
@@ -13724,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"
           },
@@ -14784,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"
           },
@@ -14838,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
               ]
             }
           },
@@ -14892,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"
           },
@@ -14925,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"
           },
@@ -15709,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
@@ -15746,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);
@@ -15757,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());
@@ -16132,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,
@@ -16157,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
@@ -16333,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: {
@@ -16531,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 }]
@@ -16614,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 ?? {}
     };
   }
@@ -19287,6 +19274,70 @@ var JupiterPriceSource = class {
   }
 };
 
+// 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");
@@ -19395,12 +19446,12 @@ var StaticPositionProvider = class {
 };
 
 // src/services/consensusOracle/kaminoPositionProvider.ts
-var import_kit12 = require("@solana/kit");
+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);
@@ -19416,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 = [];
@@ -19429,7 +19480,7 @@ 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,
@@ -19548,7 +19599,7 @@ 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
@@ -19571,8 +19622,861 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
 }
 
 // src/services/consensusOracle/consensusOracleService.ts
-var import_web326 = 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) {
@@ -19582,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));
@@ -19605,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_web326.PublicKey(pubkeyBytes).toBase58();
+    const userAccount = new import_web327.PublicKey(pubkeyBytes).toBase58();
     refs.push({
       kind: "marginfi",
       mint: "",
@@ -19630,23 +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 };
     }
-    await this.assertNoUnconfirmedYieldPayments(target);
+    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, updates, vaultState, log);
+    const { updateSignature, crankSignature, crankSkippedReason } = await this.settleVault(signer, filteredTarget, updates, vaultState, log);
     return {
       vault: target.vault,
       updates,
@@ -19656,6 +20597,43 @@ 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
@@ -19777,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);
@@ -19948,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`
       );
@@ -19965,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);
@@ -19981,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 = {}) {
@@ -20010,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();
@@ -20065,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);
@@ -20090,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);
@@ -20157,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");
       }
     }
@@ -20172,8 +21191,8 @@ var MockYieldTracker = class {
 };
 
 // src/services/externalLiquidityIntegrityService.ts
-var import_kit13 = require("@solana/kit");
-var import_web327 = 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) {
@@ -20186,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_web327.PublicKey(pubkeyBytes));
+    const userAccount = (0, import_common42.toAddress)(new import_web328.PublicKey(pubkeyBytes));
     results.push({ index: i, source: "marginfi", userAccount });
   }
   return results;
@@ -20252,7 +21271,7 @@ var ExternalLiquidityIntegrityService = class {
       return result;
     }
     const hwManagerAddress = (0, import_common42.fromWeb3Pk)(hwManager.publicKey);
-    const vaultPk = new import_web327.PublicKey(vault.toString());
+    const vaultPk = new import_web328.PublicKey(vault.toString());
     const registeredHwManager = pubkeyStr(
       vaultState.roles.hwManager
     );
@@ -20279,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) {
@@ -20395,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,
@@ -20442,6 +21467,7 @@ var ExternalLiquidityIntegrityService = class {
   WithdrawalQueueService,
   addCashflowUpdate,
   address,
+  applyEffectiveApy,
   confirmYieldPayment,
   createAccount,
   createLiveConsensusOracleDeps,
@@ -20453,7 +21479,9 @@ var ExternalLiquidityIntegrityService = class {
   dateToStr,
   defaultKeypairPath,
   deleteAccount,
+  fetchNestTokenPrice,
   findSquadsWalletRoute,
+  formatSettlementSimulation,
   fromUiAmount,
   getAccounts,
   getBalance,
@@ -20474,6 +21502,7 @@ var ExternalLiquidityIntegrityService = class {
   resolveSquadsWalletRoute,
   roundToNextUtcMidnight,
   runLiveConsensusOracle,
+  simulateConsensusOracleSettlement,
   systemClock,
   toUiAmount,
   updateAccount,