@perena/vault-sdk 1.0.24 → 1.0.26

package/dist/index.d.ts

@@ -8957,11 +8957,11 @@ type Bankineco = {
                     "name": "vaultOracle";
                     "docs": [
                         "Required when enabling tranching organically (`for_migration == false`)",
-                        "on a vault that still has main shareholders accruing fixed APY: that APY",
-                        "is only folded into `mint_share_price` while tranching is off, so a fresh",
-                        "NAV must have been settled just before the switch or the accrued APY owed",
-                        "to those shareholders is forfeited. Not needed on the migration path,",
-                        "whose accounting is reconstructed wholesale from the legacy state.",
+                        "on a vault that still has main shareholders accruing fixed APY. A fresh",
+                        "settlement establishes the regular sleeve's booked NAV and physical",
+                        "surplus immediately before the new tranche sleeve is introduced. Not",
+                        "needed on the migration path, whose accounting is reconstructed wholesale",
+                        "from the legacy state.",
                         "",
                         "Kept LAST (a trailing optional account) so legacy clients that predate it",
                         "— e.g. the migration path building against the frozen bankineco IDL —",
@@ -10146,7 +10146,9 @@ type Bankineco = {
                 "Holdings are addressed by their slot index (1 byte) to keep instruction data",
                 "small. To register a brand-new consensus holding, set `mint` to its mint",
                 "(and pass the matching `asset_mint` account); the created slot's index is used",
-                "and `holding_index` is ignored. For existing holdings leave `mint` as `None`."
+                "and `holding_index` is ignored. For existing holdings leave `mint` as `None`.",
+                "The price is authoritative only for ConsensusOracle holdings. Pyth and nested-vault",
+                "holdings use the report only for external_amount and retain their live-oracle price."
             ];
             "type": {
                 "kind": "struct";
@@ -11891,7 +11893,7 @@ type Bankineco = {
                     {
                         "name": "lossesEnabled";
                         "docs": [
-                            "Allows consensus-oracle NAV updates below the vault's current TVL."
+                            "Allows consensus-oracle NAV losses beyond the protocol's small-loss tolerance. Losses inside that tolerance settle without this flag."
                         ];
                         "type": {
                             "defined": {
@@ -11900,16 +11902,9 @@ type Bankineco = {
                         };
                     },
                     {
-                        "name": "migrationInProgress";
+                        "name": "paddingBool";
                         "docs": [
-                            "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."
+                            "Reserved byte retained for on-chain account layout compatibility."
                         ];
                         "type": {
                             "defined": {
@@ -15871,10 +15866,20 @@ interface YieldPaymentSnapshot {
  * helpers for tests and local operation.
  */
 interface YieldTracker {
+    /** Account names tagged to a vault. Live prod discovery uses this automatically. */
+    getAccountNamesForVault?(vault: Address): Promise<string[]>;
     /** All payments for an account, including payments not yet confirmed. */
     getYieldPayments(accountName: string): Promise<YieldPaymentSnapshot[]>;
     /** Sum of oracle-safe outstanding yield across the named accounts. */
     getTotalOutstandingYield(accountNames: string[], start?: Date, end?: Date): Promise<number>;
+    /**
+     * Sum the external principal and confirmed-payment-adjusted outstanding yield
+     * across the named accounts. Both values are UI token amounts.
+     */
+    getTotalTrackedAmounts(accountNames: string[], start?: Date, end?: Date): Promise<{
+        principal: number;
+        outstandingYield: number;
+    }>;
 }
 /** Injectable wall clock (ms since epoch). Lets tests pin time deterministically. */
 interface Clock {
@@ -15918,7 +15923,9 @@ interface HoldingUpdatePreview {
     lpAmount: bigint;
     /** Accrued yield attributed to this holding (base units). */
     yieldAmount: bigint;
-    /** Total external balance pushed = wallet + lp + yield. */
+    /** Yield-tracker principal attributed to this holding (base units). */
+    trackedPrincipalAmount: bigint;
+    /** Total external balance pushed = wallet + LP + tracked principal + yield. */
     externalAmount: bigint;
 }
 interface VaultOracleResult {
@@ -15955,6 +15962,8 @@ interface DecodedHolding {
     mint: unknown;
     decimals: number;
     priceOracleType: unknown;
+    /** Bound Pyth price-update or nested-vault account for live-priced holdings. */
+    priceOracleAccount?: unknown;
     isBase: unknown;
     localAmount?: unknown;
     externalAmount?: unknown;
@@ -16035,6 +16044,12 @@ interface SettlementSimulation {
     grossNav?: bigint;
     settledAccountingNav?: bigint;
     current: SettlementSimulationSnapshot;
+    /**
+     * True when `projected` was calculated by replaying the otherwise-identical
+     * settlement with the max-APY guard disabled. The real crank remains blocked
+     * until the vault config is updated.
+     */
+    projectionRequiresMaxApyDisabled?: boolean;
     projected?: SettlementSimulationSnapshot;
     performanceFees?: {
         curator: bigint;
@@ -16235,6 +16250,8 @@ declare function runLiveConsensusOracle(env: VaultEnv, oracleSigner: Keypair, op
  */
 
 interface MockYieldAccountConfig {
+    /** Optional vault address used by production-style account discovery. */
+    tag?: string;
     aprBps: number;
     /** Initial principal (UI amount). Defaults to 0. */
     principal?: number;
@@ -16252,10 +16269,15 @@ declare class MockYieldTracker implements YieldTracker {
     /** Register (or replace) a tracked account. */
     setAccount(name: string, cfg: MockYieldAccountConfig): void;
     private require;
+    getAccountNamesForVault(vault: string): Promise<string[]>;
     getYieldPayments(accountName: string): Promise<YieldPaymentSnapshot[]>;
     getYield(accountName: string, start?: Date, end?: Date): Promise<YieldAccountSnapshot>;
     getTotalYield(accountNames: string[], start?: Date, end?: Date): Promise<number>;
     getTotalOutstandingYield(accountNames: string[], start?: Date, end?: Date): Promise<number>;
+    getTotalTrackedAmounts(accountNames: string[], start?: Date, end?: Date): Promise<{
+        principal: number;
+        outstandingYield: number;
+    }>;
     getBalance(accountName: string, atTime?: Date): Promise<number>;
     addCashflow(params: {
         accountName: string;
@@ -16324,6 +16346,12 @@ declare class ConsensusOracleService {
      * balance source used by this service. Until then, no oracle update is safe.
      */
     private assertNoUnconfirmedYieldPayments;
+    /**
+     * In production, yield accounts are tagged with their vault address. Attach
+     * newly discovered accounts to the base holding, while preserving explicit
+     * per-mint mappings supplied by config or CLI flags.
+     */
+    private withDiscoveredYieldAccounts;
     /**
      * Drive several vaults in sequence. Non-fatal: a failure on one vault is
      * recorded and the rest still run (mirrors the oracle-updater daemon).
@@ -16341,6 +16369,12 @@ declare class ConsensusOracleService {
         log?: (msg: string) => void;
     }): Promise<ConsensusOracleTarget[]>;
     private fetchDecodedVault;
+    /**
+     * Keep active permissionless price sources warm so they cannot block the NAV
+     * crank after the consensus report lands. Prices are refreshed at least once
+     * per hour, or at the vault's shorter staleness interval when configured.
+     */
+    private refreshLiveOraclePrices;
     /**
      * Receipt mints issued by this vault are liabilities/shares, not underlying
      * assets for its own NAV. Exclude them even if they were registered as
@@ -16351,19 +16385,20 @@ declare class ConsensusOracleService {
     private gatherPricingInputs;
     /** Live-LP balances for the target, summed by mint (empty if no provider). */
     private fetchExternalPositions;
-    /** Accrued yield (base units) attributed to a holding via its configured accounts. */
-    private resolveYieldAmount;
+    /** Tracked external principal + outstanding yield attributed to a holding. */
+    private resolveTrackedAmounts;
     private buildUpdates;
     private buildHoldingUpdate;
     /** Push the consensus report for all holdings, then settle NAV. */
     private settleVault;
     /**
-     * Fetch the current settled NAV from the oracle account and log the APY
-     * implied by the prospective update, so MaxApyExceeded failures are diagnosable.
+     * Fetch the current settlement timestamp and log the APY implied by the
+     * prospective update, so MaxApyExceeded failures are diagnosable.
      *
      * NAV is expressed in the vault's accounting unit (scaled by assetDecimals).
-     * prospective NAV = Σ ((localAmount_i + externalAmount_i) * price_i)
-     *                   / 10^assetDecimals
+     * Mirrors `gross_nav_from_holdings`: consensus updates overlay their target
+     * slots, while live-priced and otherwise unchanged holdings retain their
+     * current price/external amount.
      */
     private logProspectiveApy;
 }

package/dist/index.js

@@ -1532,7 +1532,8 @@ var PROTOCOL_FEE_RECIPIENT = (0, import_kit.address)(
 var PROGRAM_FEE_EXEMPT_OWNER_WHITELIST = [
   (0, import_kit.address)("Hobbakk1LmW2DhE4nAKnCeU1iK7V7pKHTq3ihaE2i8qG"),
   (0, import_kit.address)("7C39GeKrqLygmgV9D4bicUaiyFhKrX6Eevk6PDACwuj7"),
-  (0, import_kit.address)("LYC8YiiSzQfPpxUW2tpxfuPKGZwywAJhXKUfDP2B66f")
+  (0, import_kit.address)("LYC8YiiSzQfPpxUW2tpxfuPKGZwywAJhXKUfDP2B66f"),
+  (0, import_kit.address)("soBBAHNhFyWF4QBCK9BJLVkX6d6NZt37ozNaPV5aq3H")
 ];
 var VAULT_CREATOR_WHITELIST = [
   (0, import_kit.address)("4jMRBkpWrfhhwFYTwG3o7hmsXQwbJUwdyUX8htB6KwLJ")
@@ -10463,11 +10464,11 @@ var IDL = {
           "name": "vault_oracle",
           "docs": [
             "Required when enabling tranching organically (`for_migration == false`)",
-            "on a vault that still has main shareholders accruing fixed APY: that APY",
-            "is only folded into `mint_share_price` while tranching is off, so a fresh",
-            "NAV must have been settled just before the switch or the accrued APY owed",
-            "to those shareholders is forfeited. Not needed on the migration path,",
-            "whose accounting is reconstructed wholesale from the legacy state.",
+            "on a vault that still has main shareholders accruing fixed APY. A fresh",
+            "settlement establishes the regular sleeve's booked NAV and physical",
+            "surplus immediately before the new tranche sleeve is introduced. Not",
+            "needed on the migration path, whose accounting is reconstructed wholesale",
+            "from the legacy state.",
             "",
             "Kept LAST (a trailing optional account) so legacy clients that predate it",
             "\u2014 e.g. the migration path building against the frozen bankineco IDL \u2014",
@@ -11652,7 +11653,9 @@ var IDL = {
         "Holdings are addressed by their slot index (1 byte) to keep instruction data",
         "small. To register a brand-new consensus holding, set `mint` to its mint",
         "(and pass the matching `asset_mint` account); the created slot's index is used",
-        "and `holding_index` is ignored. For existing holdings leave `mint` as `None`."
+        "and `holding_index` is ignored. For existing holdings leave `mint` as `None`.",
+        "The price is authoritative only for ConsensusOracle holdings. Pyth and nested-vault",
+        "holdings use the report only for external_amount and retain their live-oracle price."
       ],
       "type": {
         "kind": "struct",
@@ -13397,7 +13400,7 @@ var IDL = {
           {
             "name": "losses_enabled",
             "docs": [
-              "Allows consensus-oracle NAV updates below the vault's current TVL."
+              "Allows consensus-oracle NAV losses beyond the protocol's small-loss tolerance. Losses inside that tolerance settle without this flag."
             ],
             "type": {
               "defined": {
@@ -13406,16 +13409,9 @@ var IDL = {
             }
           },
           {
-            "name": "migration_in_progress",
+            "name": "_padding_bool",
             "docs": [
-              "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."
+              "Reserved byte retained for on-chain account layout compatibility."
             ],
             "type": {
               "defined": {
@@ -19595,6 +19591,7 @@ var MarginfiPositionProvider = class {
 };
 
 // src/services/consensusOracle/liveConsensusOracleDeps.ts
+var YIELD_TRACKER_DECIMALS = 6;
 function createLiveConsensusOracleDeps(connection, opts = {}) {
   const log = opts.log ?? (() => {
   });
@@ -19605,7 +19602,27 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
       log
     }),
     yieldTracker: {
-      getTotalOutstandingYield,
+      async getAccountNamesForVault(vault) {
+        const accounts2 = await getAccounts();
+        return accounts2.filter((account) => account.tag === vault.toString()).map((account) => account.name);
+      },
+      async getTotalOutstandingYield(accountNames, start, end) {
+        const raw = await getTotalOutstandingYield(accountNames, start, end);
+        return raw / 10 ** YIELD_TRACKER_DECIMALS;
+      },
+      async getTotalTrackedAmounts(accountNames, start, end) {
+        let principal = 0;
+        let outstandingYield = 0;
+        for (const accountName of accountNames) {
+          const snapshot2 = await getYield(accountName, start, end);
+          principal += snapshot2.principal_at_end;
+          outstandingYield += snapshot2.outstanding_yield;
+        }
+        return {
+          principal: principal / 10 ** YIELD_TRACKER_DECIMALS,
+          outstandingYield: outstandingYield / 10 ** YIELD_TRACKER_DECIMALS
+        };
+      },
       getYieldPayments
     }
   };
@@ -19630,6 +19647,7 @@ var import_kit14 = require("@solana/kit");
 var import_web326 = require("@solana/web3.js");
 var DEFAULT_SHARE_PRICE = 1000000n;
 var BPS_DENOMINATOR2 = 10000n;
+var NAV_LOSS_TOLERANCE_BPS = 25n;
 var SECONDS_PER_YEAR = 31536000n;
 var DEFAULT_STALENESS_SECS = 86400n;
 var CONSENSUS_MAX_DIFF_BPS = 8n;
@@ -19744,6 +19762,7 @@ function simulateConsensusOracleSettlement(args) {
       hwmSharePrice: bigint(vaultAccounting.hwmSharePrice),
       fixedApyBps: number(apyConfig.fixedApyBps),
       maxApyBps: number(apyConfig.maxApyBps),
+      accruedApyBalance: bigint(apyConfig.accruedApyBalance),
       apyAnchorSharePrice: bigint(apyConfig.anchorSharePrice),
       apyAnchorTs: bigint(apyConfig.anchorTs),
       tranche: currentTranche
@@ -19763,7 +19782,52 @@ function simulateConsensusOracleSettlement(args) {
       performanceFees: settlement.performanceFees
     };
   } catch (error) {
-    blockers.push(message(error));
+    const blocker = message(error);
+    blockers.push(blocker);
+    if (blocker.includes("MaxApyExceeded")) {
+      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: 0,
+          accruedApyBalance: bigint(apyConfig.accruedApyBalance),
+          apyAnchorSharePrice: bigint(apyConfig.anchorSharePrice),
+          apyAnchorTs: bigint(apyConfig.anchorTs),
+          tranche: currentTranche
+        });
+        return {
+          nowTs: args.nowTs,
+          assetDecimals: args.vault.config.assetDecimals,
+          ...consensusSummary,
+          canSettle: false,
+          blockers,
+          warnings,
+          consensus,
+          grossNav,
+          settledAccountingNav: settlement.settledAccountingNav,
+          current,
+          projectionRequiresMaxApyDisabled: true,
+          projected: settlement.projected,
+          performanceFees: settlement.performanceFees
+        };
+      } catch (projectionError) {
+        warnings.push(
+          `could not calculate the uncapped projection: ${message(
+            projectionError
+          )}`
+        );
+      }
+    }
     return {
       nowTs: args.nowTs,
       assetDecimals: args.vault.config.assetDecimals,
@@ -19781,18 +19845,19 @@ 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") {
+    if (holding.cleared || holding.priceOracleType === "none") {
       continue;
     }
     const reports = entries.filter(
       (entry) => entry.signer !== import_web326.PublicKey.default.toBase58() && isFresh(entry.lastUpdateTs, nowTs, stalenessThresholdSecs) && (entry.prices[index] ?? 0n) > 0n
     );
+    const usesConsensusPrice = holding.priceOracleType === "consensusoracle";
     const prices = reports.map((entry) => entry.prices[index] ?? 0n);
     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)) {
+    } else if (usesConsensusPrice && !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`;
@@ -19807,18 +19872,20 @@ function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
       });
       continue;
     }
-    const settledPrice = average(prices);
+    const settledPrice = usesConsensusPrice ? average(prices) : void 0;
     const settledExternalAmount = average(amounts);
     const latestTs = reports.reduce(
       (latest, entry) => entry.lastUpdateTs > latest ? entry.lastUpdateTs : latest,
       0n
     );
-    const wouldUpdateHolding = latestTs > holding.lastUpdateTs && latestTs <= nowTs;
+    const wouldUpdateHolding = usesConsensusPrice ? latestTs > holding.lastUpdateTs && latestTs <= nowTs : latestTs <= nowTs;
     if (wouldUpdateHolding) {
-      holding.price = settledPrice;
+      if (settledPrice !== void 0) {
+        holding.price = settledPrice;
+        holding.lastUpdateTs = latestTs;
+      }
       holding.externalAmount = settledExternalAmount;
-      holding.lastUpdateTs = latestTs;
-      if (!holding.isBase && holding.localAmount === 0n && holding.externalAmount === 0n) {
+      if (usesConsensusPrice && !holding.isBase && holding.localAmount === 0n && holding.externalAmount === 0n) {
         holding.cleared = true;
       }
     }
@@ -19835,16 +19902,20 @@ function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
   return results;
 }
 function settleVault(args) {
-  if (args.grossNav < args.currentTvl && !args.lossesEnabled) {
+  const regularSurplusBefore = args.tranche ? max(args.accruedApyBalance, 0n) : 0n;
+  const physicalNavBefore = args.currentTvl + regularSurplusBefore;
+  const loss = args.grossNav < physicalNavBefore ? physicalNavBefore - args.grossNav : 0n;
+  const lossExceedsTolerance = loss * BPS_DENOMINATOR2 > physicalNavBefore * NAV_LOSS_TOLERANCE_BPS;
+  if (lossExceedsTolerance && !args.lossesEnabled) {
     throw new Error(
-      `crank would fail LossesDisabled: gross NAV ${args.grossNav} < current TVL ${args.currentTvl}`
+      `crank would fail LossesDisabled: gross NAV ${args.grossNav} is more than ${NAV_LOSS_TOLERANCE_BPS}bps below physical NAV ${physicalNavBefore}`
     );
   }
   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,
+      args.tranche ? physicalNavBefore : args.currentSharePrice,
       priorTs,
       nextApyValue,
       args.nowTs,
@@ -19857,13 +19928,22 @@ function settleVault(args) {
   let protocolFee = 0n;
   let settledAccountingNav;
   if (args.tranche) {
-    settledAccountingNav = args.grossNav;
-    regularValue = settleTrancheNav(
+    const regularGrossValue = settleTrancheNav(
       args.tranche,
-      args.currentTvl,
-      settledAccountingNav,
+      physicalNavBefore,
+      args.grossNav,
       args.nowTs
     );
+    regularValue = settleFixedApyNav({
+      currentSharePrice: args.currentSharePrice,
+      reportedNav: regularGrossValue,
+      nowTs: args.nowTs,
+      totalSupply: args.totalSupply,
+      fixedApyBps: args.fixedApyBps,
+      anchorSharePrice: args.apyAnchorSharePrice,
+      anchorTs: args.apyAnchorTs
+    });
+    settledAccountingNav = regularValue + args.tranche.junior.value + args.tranche.senior.value;
     const juniorFees = settleShareClassPerformanceFee(
       args.tranche.junior,
       args.performanceFeeBps,
@@ -20031,7 +20111,8 @@ function settleRegularPerformanceFee(grossValue, supply, hwmSharePrice, performa
   };
 }
 function settleFixedApyNav(args) {
-  if (args.fixedApyBps === 0 || args.currentSharePrice === 0n || args.totalSupply === 0n || args.anchorSharePrice === 0n || args.anchorTs <= 0n) {
+  if (args.totalSupply === 0n) return 0n;
+  if (args.fixedApyBps === 0 || args.currentSharePrice === 0n || args.anchorSharePrice === 0n || args.anchorTs <= 0n) {
     return args.reportedNav;
   }
   if (args.nowTs <= args.anchorTs) {
@@ -20408,6 +20489,9 @@ function formatSettlementSimulation(simulation) {
     );
   }
   if (simulation.projected) {
+    if (simulation.projectionRequiresMaxApyDisabled) {
+      lines.push("    projection with max APY disabled (max_apy_bps=0):");
+    }
     lines.push(
       `    TVL:       ${formatTransition(
         simulation.current.tvl,
@@ -20478,8 +20562,27 @@ function formatUnits(value, decimals) {
 
 // src/services/consensusOracle/consensusOracleService.ts
 var SYSTEM_PROGRAM2 = "11111111111111111111111111111111";
+var PRICE_ORACLE_TYPES_BY_INDEX2 = [
+  "none",
+  "consensusOracle",
+  "pyth",
+  "perenaVault"
+];
 var CONSENSUS_ORACLE_VARIANT = "consensusoracle";
+var LIVE_ORACLE_VARIANTS = /* @__PURE__ */ new Set(["pyth", "perenavault"]);
+var REPORTABLE_ORACLE_VARIANTS = /* @__PURE__ */ new Set([
+  CONSENSUS_ORACLE_VARIANT,
+  ...LIVE_ORACLE_VARIANTS
+]);
+var LIVE_PRICE_REFRESH_INTERVAL_SECS = 60n * 60n;
+var DEFAULT_PRICE_STALENESS_THRESHOLD_SECS3 = 24n * 60n * 60n;
 function variantName2(value) {
+  if (typeof value === "number") {
+    return PRICE_ORACLE_TYPES_BY_INDEX2[value] ?? String(value);
+  }
+  if (typeof value === "bigint") {
+    return PRICE_ORACLE_TYPES_BY_INDEX2[Number(value)] ?? String(value);
+  }
   if (value && typeof value === "object") return Object.keys(value)[0] ?? "";
   return String(value ?? "");
 }
@@ -20489,6 +20592,13 @@ function coerceBool3(value) {
   const record2 = value;
   return Boolean(record2?.value ?? record2?.[0]);
 }
+function toBigInt2(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(Math.trunc(value));
+  if (typeof value === "string" && value.length > 0) return BigInt(value);
+  if (value !== null && value !== void 0) return BigInt(String(value));
+  return 0n;
+}
 function priceInAccountingUnit(usd, baseUsd, assetDecimals) {
   return BigInt(Math.round(usd / baseUsd * 10 ** assetDecimals));
 }
@@ -20533,9 +20643,19 @@ var ConsensusOracleService = class {
     const log = opts.log ?? (() => {
     });
     const dryRun = opts.dryRun ?? false;
-    const vaultState = await this.fetchDecodedVault(target.vault);
+    let vaultState = await this.fetchDecodedVault(target.vault);
+    const refreshedLivePrices = await this.refreshLiveOraclePrices(
+      signer,
+      target.vault,
+      vaultState,
+      log,
+      dryRun
+    );
+    if (refreshedLivePrices) {
+      vaultState = await this.fetchDecodedVault(target.vault);
+    }
     const receiptMints = await this.fetchReceiptMints(target.vault, vaultState);
-    const consensusHoldings = selectConsensusHoldings(
+    const reportableHoldings = selectReportableHoldings(
       vaultState.holdings,
       receiptMints
     );
@@ -20547,18 +20667,24 @@ var ConsensusOracleService = class {
         `vault ${target.vault}: excluded ${filteredCount} vault/tranche receipt mint holding(s)`
       );
     }
-    if (consensusHoldings.length === 0) {
-      log(`vault ${target.vault}: no consensus holdings, skipping`);
+    if (reportableHoldings.length === 0) {
+      log(`vault ${target.vault}: no oracle-priced holdings, skipping`);
       return { vault: target.vault, updates: [], dryRun };
     }
-    const filteredTarget = filterTargetHoldings(target, receiptMints);
+    let filteredTarget = filterTargetHoldings(target, receiptMints);
+    filteredTarget = await this.withDiscoveredYieldAccounts(
+      filteredTarget,
+      vaultState,
+      receiptMints,
+      log
+    );
     await this.assertNoUnconfirmedYieldPayments(filteredTarget);
     const inputs = await this.gatherPricingInputs(
       filteredTarget,
       vaultState,
-      consensusHoldings
+      reportableHoldings
     );
-    const updates = await this.buildUpdates(consensusHoldings, inputs);
+    const updates = await this.buildUpdates(reportableHoldings, inputs);
     if (dryRun) {
       log(`vault ${target.vault}: dry run, ${updates.length} holding(s)`);
       try {
@@ -20667,6 +20793,56 @@ var ConsensusOracleService = class {
       }
     }
   }
+  /**
+   * In production, yield accounts are tagged with their vault address. Attach
+   * newly discovered accounts to the base holding, while preserving explicit
+   * per-mint mappings supplied by config or CLI flags.
+   */
+  async withDiscoveredYieldAccounts(target, vaultState, excludedMints, log) {
+    const yieldTracker = this.deps.yieldTracker;
+    if (!yieldTracker?.getAccountNamesForVault) return target;
+    const discovered = [
+      ...new Set(await yieldTracker.getAccountNamesForVault(target.vault))
+    ];
+    const alreadyConfigured = new Set(
+      (target.holdings ?? []).flatMap(
+        (holding) => holding.yieldAccountNames ?? []
+      )
+    );
+    const namesToAttach = discovered.filter(
+      (name) => !alreadyConfigured.has(name)
+    );
+    if (namesToAttach.length === 0) return target;
+    const baseHolding = vaultState.holdings.find((holding) => {
+      const mint = (0, import_common41.fromWeb3Pk)(holding.mint).toString();
+      return coerceBool3(holding.isBase) && !excludedMints.has(mint);
+    });
+    if (!baseHolding) {
+      throw new Error(
+        `vault ${target.vault}: tagged yield accounts found but no base holding is available`
+      );
+    }
+    const baseMint = (0, import_common41.fromWeb3Pk)(baseHolding.mint);
+    const holdings = [...target.holdings ?? []];
+    const existingIndex = holdings.findIndex(
+      (holding) => holding.mint.toString() === baseMint.toString()
+    );
+    if (existingIndex >= 0) {
+      const existing = holdings[existingIndex];
+      holdings[existingIndex] = {
+        ...existing,
+        yieldAccountNames: [
+          .../* @__PURE__ */ new Set([...existing.yieldAccountNames ?? [], ...namesToAttach])
+        ]
+      };
+    } else {
+      holdings.push({ mint: baseMint, yieldAccountNames: namesToAttach });
+    }
+    log(
+      `vault ${target.vault}: attached ${namesToAttach.length} tagged yield account(s) to base holding ${baseMint}`
+    );
+    return { ...target, holdings };
+  }
   /**
    * Drive several vaults in sequence. Non-fatal: a failure on one vault is
    * recorded and the rest still run (mirrors the oracle-updater daemon).
@@ -20755,6 +20931,64 @@ var ConsensusOracleService = class {
       fresh: true
     });
   }
+  /**
+   * Keep active permissionless price sources warm so they cannot block the NAV
+   * crank after the consensus report lands. Prices are refreshed at least once
+   * per hour, or at the vault's shorter staleness interval when configured.
+   */
+  async refreshLiveOraclePrices(signer, vault, vaultState, log, dryRun) {
+    const nowSecs = BigInt(Math.floor(this.clock.now() / 1e3));
+    const configuredStaleness = toBigInt2(
+      vaultState.config.priceStalenessThresholdSecs
+    );
+    const stalenessThreshold = configuredStaleness > 0n ? configuredStaleness : DEFAULT_PRICE_STALENESS_THRESHOLD_SECS3;
+    const refreshInterval = stalenessThreshold < LIVE_PRICE_REFRESH_INTERVAL_SECS ? stalenessThreshold : LIVE_PRICE_REFRESH_INTERVAL_SECS;
+    const targets = [];
+    for (const holding of vaultState.holdings) {
+      const oracleType = variantName2(holding.priceOracleType).toLowerCase();
+      if (!LIVE_ORACLE_VARIANTS.has(oracleType)) continue;
+      const mint = (0, import_common41.fromWeb3Pk)(holding.mint);
+      if (mint.toString() === SYSTEM_PROGRAM2) continue;
+      const activeAmount = toBigInt2(holding.localAmount) + toBigInt2(holding.externalAmount);
+      if (activeAmount === 0n) continue;
+      const lastUpdateTs = toBigInt2(holding.lastUpdateTs);
+      const ageSecs = nowSecs - lastUpdateTs;
+      if (lastUpdateTs > 0n && ageSecs >= 0n && ageSecs < refreshInterval) {
+        continue;
+      }
+      if (!holding.priceOracleAccount) {
+        log(
+          `vault ${vault}: cannot refresh ${mint}; ${oracleType} holding has no oracle account`
+        );
+        continue;
+      }
+      const oracleAccount = (0, import_common41.fromWeb3Pk)(holding.priceOracleAccount);
+      if (oracleAccount.toString() === SYSTEM_PROGRAM2) {
+        log(
+          `vault ${vault}: cannot refresh ${mint}; ${oracleType} holding has no oracle account`
+        );
+        continue;
+      }
+      targets.push({ mint, oracleAccount });
+    }
+    if (targets.length === 0) return false;
+    if (dryRun) {
+      log(
+        `vault ${vault}: dry run, would refresh ${targets.length} live asset price(s)`
+      );
+      return false;
+    }
+    log(
+      `vault ${vault}: refreshing ${targets.length} live asset price(s) due for hourly refresh`
+    );
+    const results = await this.oracle.refreshAssetPrices(
+      signer,
+      vault,
+      targets,
+      log
+    );
+    return results.some((result) => Boolean(result.signature));
+  }
   /**
    * Receipt mints issued by this vault are liabilities/shares, not underlying
    * assets for its own NAV. Exclude them even if they were registered as
@@ -20778,17 +21012,21 @@ var ConsensusOracleService = class {
     return receiptMints;
   }
   /** Fetch every external input the per-holding updates draw on, in parallel-ish. */
-  async gatherPricingInputs(target, vaultState, consensusHoldings) {
+  async gatherPricingInputs(target, vaultState, reportableHoldings) {
     const manager = (0, import_common41.fromWeb3Pk)(vaultState.roles.manager);
-    const holdingMints = consensusHoldings.map(
-      ({ holding }) => (0, import_common41.fromWeb3Pk)(holding.mint)
-    );
+    const consensusMints = reportableHoldings.filter(
+      ({ holding }) => variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT
+    ).map(({ holding }) => (0, import_common41.fromWeb3Pk)(holding.mint));
     const baseHolding = vaultState.holdings.find((h) => coerceBool3(h.isBase));
-    const baseMint = baseHolding ? (0, import_common41.fromWeb3Pk)(baseHolding.mint) : holdingMints[0];
+    const baseMint = baseHolding ? (0, import_common41.fromWeb3Pk)(baseHolding.mint) : consensusMints[0];
     if (!baseMint) {
       throw new Error(`vault has no holdings \u2014 cannot determine base asset`);
     }
-    const mintsToPrice = holdingMints.includes(baseMint) ? holdingMints : [...holdingMints, baseMint];
+    const mintsToPrice = [
+      ...new Map(
+        [...consensusMints, baseMint].map((mint) => [mint.toString(), mint])
+      ).values()
+    ];
     const usdPrices = await this.deps.priceSource.fetchUsdPrices(mintsToPrice);
     const baseUsd = usdPrices[baseMint.toString()];
     if (!baseUsd) {
@@ -20837,18 +21075,23 @@ var ConsensusOracleService = class {
     });
     return sumPositionsByMint(positions);
   }
-  /** Accrued yield (base units) attributed to a holding via its configured accounts. */
-  async resolveYieldAmount(cfg, decimals) {
-    if (!this.deps.yieldTracker || !cfg?.yieldAccountNames?.length) return 0n;
-    const totalYieldUi = await this.deps.yieldTracker.getTotalOutstandingYield(
+  /** Tracked external principal + outstanding yield attributed to a holding. */
+  async resolveTrackedAmounts(cfg, decimals) {
+    if (!this.deps.yieldTracker || !cfg?.yieldAccountNames?.length) {
+      return { principalAmount: 0n, yieldAmount: 0n };
+    }
+    const tracked = await this.deps.yieldTracker.getTotalTrackedAmounts(
       cfg.yieldAccountNames
     );
-    return totalYieldUi > 0 ? (0, import_common41.fromUiAmount)(totalYieldUi, decimals) : 0n;
+    return {
+      principalAmount: tracked.principal > 0 ? (0, import_common41.fromUiAmount)(tracked.principal, decimals) : 0n,
+      yieldAmount: tracked.outstandingYield > 0 ? (0, import_common41.fromUiAmount)(tracked.outstandingYield, decimals) : 0n
+    };
   }
   // ── Aggregation ──────────────────────────────────────────────────────────────
-  async buildUpdates(consensusHoldings, inputs) {
+  async buildUpdates(reportableHoldings, inputs) {
     const updates = [];
-    for (const entry of consensusHoldings) {
+    for (const entry of reportableHoldings) {
       updates.push(await this.buildHoldingUpdate(entry, inputs));
     }
     return updates;
@@ -20857,18 +21100,25 @@ var ConsensusOracleService = class {
     const { holding, holdingIndex } = entry;
     const mint = (0, import_common41.fromWeb3Pk)(holding.mint);
     const mintKey = mint.toString();
-    const usd = coerceBool3(holding.isBase) ? inputs.baseUsd : inputs.usdPrices[mintKey];
-    if (!usd) {
-      throw new Error(`no USD price for holding ${mint}`);
+    const oracleType = variantName2(holding.priceOracleType).toLowerCase();
+    let usd;
+    let price;
+    if (oracleType === CONSENSUS_ORACLE_VARIANT) {
+      usd = coerceBool3(holding.isBase) ? inputs.baseUsd : inputs.usdPrices[mintKey];
+      if (!usd) throw new Error(`no USD price for holding ${mint}`);
+      price = priceInAccountingUnit(usd, inputs.baseUsd, inputs.assetDecimals);
+    } else {
+      price = toBigInt2(holding.price);
+      if (price <= 0n) {
+        throw new Error(
+          `live-oracle holding ${mint} has no on-chain price to preserve`
+        );
+      }
+      usd = Number(price) / 10 ** inputs.assetDecimals * inputs.baseUsd;
     }
-    const price = priceInAccountingUnit(
-      usd,
-      inputs.baseUsd,
-      inputs.assetDecimals
-    );
     const walletAmount = inputs.walletBalances[mintKey] ?? 0n;
     const lpAmount = inputs.lpByMint.get(mintKey) ?? 0n;
-    const yieldAmount = await this.resolveYieldAmount(
+    const { principalAmount, yieldAmount } = await this.resolveTrackedAmounts(
       inputs.configByMint.get(mintKey),
       holding.decimals
     );
@@ -20881,7 +21131,8 @@ var ConsensusOracleService = class {
       walletAmount,
       lpAmount,
       yieldAmount,
-      externalAmount: walletAmount + lpAmount + yieldAmount
+      trackedPrincipalAmount: principalAmount,
+      externalAmount: walletAmount + lpAmount + principalAmount + yieldAmount
     };
   }
   // ── Settlement ───────────────────────────────────────────────────────────────
@@ -20893,7 +21144,7 @@ var ConsensusOracleService = class {
     );
     for (const update of updates) {
       log(
-        `  holding #${update.holdingIndex} ${update.mint}: price=${update.price} external_amount=${update.externalAmount} [wallet=${update.walletAmount} lp=${update.lpAmount} yield=${update.yieldAmount}]`
+        `  holding #${update.holdingIndex} ${update.mint}: price=${update.price} external_amount=${update.externalAmount} [wallet=${update.walletAmount} lp=${update.lpAmount} principal=${update.trackedPrincipalAmount} yield=${update.yieldAmount}]`
       );
     }
     await this.logProspectiveApy(vault, updates, vaultState, log);
@@ -20922,12 +21173,13 @@ var ConsensusOracleService = class {
     };
   }
   /**
-   * Fetch the current settled NAV from the oracle account and log the APY
-   * implied by the prospective update, so MaxApyExceeded failures are diagnosable.
+   * Fetch the current settlement timestamp and log the APY implied by the
+   * prospective update, so MaxApyExceeded failures are diagnosable.
    *
    * NAV is expressed in the vault's accounting unit (scaled by assetDecimals).
-   * prospective NAV = Σ ((localAmount_i + externalAmount_i) * price_i)
-   *                   / 10^assetDecimals
+   * Mirrors `gross_nav_from_holdings`: consensus updates overlay their target
+   * slots, while live-priced and otherwise unchanged holdings retain their
+   * current price/external amount.
    */
   async logProspectiveApy(vault, updates, vaultState, log) {
     try {
@@ -20936,22 +21188,39 @@ var ConsensusOracleService = class {
       });
       const data = oracle.data;
       if (!data || data.length < 16) return;
-      const settledNav = readI64LE(data, 0);
       const settledNavTs = readI64LE(data, 8);
-      if (settledNav <= 0n || settledNavTs <= 0n) return;
-      const scale = BigInt(10 ** vaultState.config.assetDecimals);
-      const prospectiveNav = updates.reduce((sum, u) => {
-        const holding = vaultState.holdings[u.holdingIndex];
-        const localAmount = BigInt(holding?.localAmount?.toString() ?? "0");
-        return sum + (localAmount + u.externalAmount) * u.price / scale;
-      }, 0n);
+      if (settledNavTs <= 0n) return;
+      const updatesByIndex = new Map(
+        updates.map((update) => [update.holdingIndex, update])
+      );
+      const prospectiveNav = vaultState.holdings.reduce(
+        (sum, holding, holdingIndex) => {
+          const mint = (0, import_common41.fromWeb3Pk)(holding.mint).toString();
+          if (mint === SYSTEM_PROGRAM2) return sum;
+          const update = updatesByIndex.get(holdingIndex);
+          const localAmount = toBigInt2(holding.localAmount);
+          const externalAmount = update ? update.externalAmount : toBigInt2(holding.externalAmount);
+          const amount = localAmount + externalAmount;
+          if (amount === 0n) return sum;
+          const usesConsensusPrice = variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT;
+          const price = update && usesConsensusPrice ? update.price : toBigInt2(holding.price);
+          if (price <= 0n) return sum;
+          const scale = 10n ** BigInt(holding.decimals);
+          return sum + amount * price / scale;
+        },
+        0n
+      );
+      const currentTvl = toBigInt2(vaultState.accounting?.tvl);
+      const accruedApyBalance = coerceBool3(vaultState.tranchingEnabled) ? toBigInt2(vaultState.config.apy?.accruedApyBalance) : 0n;
+      const physicalNavBefore = currentTvl + (accruedApyBalance > 0n ? accruedApyBalance : 0n);
+      if (physicalNavBefore <= 0n) return;
       const nowSecs = BigInt(Math.floor(this.clock.now() / 1e3));
       const elapsedSecs = nowSecs - settledNavTs;
       if (elapsedSecs <= 0n) return;
       const SECONDS_PER_YEAR3 = 365n * 24n * 3600n;
-      const apyBps = (prospectiveNav - settledNav) * SECONDS_PER_YEAR3 * 10000n / (settledNav * elapsedSecs);
+      const apyBps = (prospectiveNav - physicalNavBefore) * SECONDS_PER_YEAR3 * 10000n / (physicalNavBefore * elapsedSecs);
       log(
-        `vault ${vault}: prospective NAV ${prospectiveNav} vs settled ${settledNav} (elapsed ${elapsedSecs}s) \u2192 implied APY ${apyBps}bps`
+        `vault ${vault}: prospective NAV ${prospectiveNav} vs physical baseline ${physicalNavBefore} (elapsed ${elapsedSecs}s) \u2192 implied APY ${apyBps}bps`
       );
     } catch {
     }
@@ -20991,10 +21260,12 @@ function signerInOracleData(data, signerBytes) {
   }
   return false;
 }
-function selectConsensusHoldings(holdings, excludedMints = /* @__PURE__ */ new Set()) {
+function selectReportableHoldings(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 && !excludedMints.has(mint.toString()) && variantName2(holding.priceOracleType).toLowerCase() === CONSENSUS_ORACLE_VARIANT;
+    return mint !== SYSTEM_PROGRAM2 && !excludedMints.has(mint.toString()) && REPORTABLE_ORACLE_VARIANTS.has(
+      variantName2(holding.priceOracleType).toLowerCase()
+    );
   });
 }
 function filterTargetHoldings(target, excludedMints) {
@@ -21036,6 +21307,7 @@ var MockYieldTracker = class {
     this.clock = opts.clock ?? systemClock;
     for (const [name, cfg] of Object.entries(opts.accounts ?? {})) {
       this.accounts.set(name, {
+        tag: cfg.tag,
         aprBps: cfg.aprBps,
         initialPrincipal: cfg.principal ?? 0,
         startTs: cfg.startTs ?? this.clock.now(),
@@ -21047,6 +21319,7 @@ var MockYieldTracker = class {
   /** Register (or replace) a tracked account. */
   setAccount(name, cfg) {
     this.accounts.set(name, {
+      tag: cfg.tag,
       aprBps: cfg.aprBps,
       initialPrincipal: cfg.principal ?? 0,
       startTs: cfg.startTs ?? this.clock.now(),
@@ -21061,6 +21334,9 @@ var MockYieldTracker = class {
     }
     return state;
   }
+  async getAccountNamesForVault(vault) {
+    return [...this.accounts.entries()].filter(([, state]) => state.tag === vault.toString()).map(([name]) => name);
+  }
   async getYieldPayments(accountName) {
     return this.require(accountName).yieldPayments.map((payment) => ({
       id: payment.paymentId,
@@ -21122,6 +21398,16 @@ var MockYieldTracker = class {
     }
     return total;
   }
+  async getTotalTrackedAmounts(accountNames, start, end) {
+    let principal = 0;
+    let outstandingYield = 0;
+    for (const name of accountNames) {
+      const snapshot2 = await this.getYield(name, start, end);
+      principal += snapshot2.principalAtEnd;
+      outstandingYield += snapshot2.outstandingYield;
+    }
+    return { principal, outstandingYield };
+  }
   async getBalance(accountName, atTime) {
     const snapshot2 = await this.getYield(accountName, void 0, atTime);
     return snapshot2.principalAtEnd + snapshot2.outstandingYield;
@@ -21210,7 +21496,7 @@ function parseActiveSlots(externalLiquidity) {
   }
   return results;
 }
-function toBigInt2(value) {
+function toBigInt3(value) {
   if (typeof value === "bigint") return value;
   if (value !== null && value !== void 0) return BigInt(String(value));
   return 0n;
@@ -21290,7 +21576,7 @@ var ExternalLiquidityIntegrityService = class {
       }
       const holdings = vaultState.holdings.filter((h) => {
         const mint = pubkeyStr(h.mint);
-        return !isZeroPubkey2(mint) && toBigInt2(h.localAmount) > 0n;
+        return !isZeroPubkey2(mint) && toBigInt3(h.localAmount) > 0n;
       });
       if (holdings.length === 0) {
         log(`Vault ${vault} slot ${slot.index}: no local balance to deploy`);
@@ -21299,7 +21585,7 @@ var ExternalLiquidityIntegrityService = class {
       }
       for (const holding of holdings) {
         const mintAddress = (0, import_kit15.address)(pubkeyStr(holding.mint));
-        const localAmount = toBigInt2(holding.localAmount);
+        const localAmount = toBigInt3(holding.localAmount);
         const marginfiAccounts = (0, import_marginfi2.marginfiAccountsForMint)(mintAddress);
         if (!marginfiAccounts) {
           log(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perena/vault-sdk",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Vault program helpers for Bankineco integrations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,6 +38,7 @@
     "create-vault": "tsx scripts/createVault.ts",
     "init-vault-atas": "tsx scripts/initVaultAtas.ts",
     "inspect": "tsx scripts/inspect.ts",
+    "vault-data": "tsx scripts/fetchVaultData.ts",
     "simulate-withdraw": "tsx scripts/simulate-withdraw.ts",
     "simulate-message": "tsx scripts/simulate-message.ts",
     "run-external-liquidity-service": "tsx scripts/runExternalLiquidityService.ts"
@@ -56,6 +57,7 @@
   },
   "devDependencies": {
     "common": "file:../common",
+    "jupiter": "file:../jupiter",
     "marginfi": "file:../marginfi",
     "@types/node": "^24.3.1",
     "prettier": "^2.6.2",