@perena/vault-sdk 1.0.25 → 1.0.26

package/dist/index.d.ts

@@ -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": {
@@ -15864,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 {
@@ -15911,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 {
@@ -16236,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;
@@ -16253,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;
@@ -16325,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).
@@ -16358,8 +16385,8 @@ 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. */

package/dist/index.js

@@ -11653,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",
@@ -13398,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": {
@@ -19600,10 +19602,27 @@ function createLiveConsensusOracleDeps(connection, opts = {}) {
       log
     }),
     yieldTracker: {
+      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
     }
   };
@@ -19628,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;
@@ -19825,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`;
@@ -19851,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;
       }
     }
@@ -19881,9 +19904,11 @@ function applyConsensus(holdings, entries, nowTs, stalenessThresholdSecs) {
 function settleVault(args) {
   const regularSurplusBefore = args.tranche ? max(args.accruedApyBalance, 0n) : 0n;
   const physicalNavBefore = args.currentTvl + regularSurplusBefore;
-  if (args.grossNav < physicalNavBefore && !args.lossesEnabled) {
+  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} < physical NAV ${physicalNavBefore}`
+      `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);
@@ -20545,6 +20570,10 @@ var PRICE_ORACLE_TYPES_BY_INDEX2 = [
 ];
 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) {
@@ -20626,7 +20655,7 @@ var ConsensusOracleService = class {
       vaultState = await this.fetchDecodedVault(target.vault);
     }
     const receiptMints = await this.fetchReceiptMints(target.vault, vaultState);
-    const consensusHoldings = selectConsensusHoldings(
+    const reportableHoldings = selectReportableHoldings(
       vaultState.holdings,
       receiptMints
     );
@@ -20638,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 {
@@ -20758,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).
@@ -20927,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) {
@@ -20986,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;
@@ -21006,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
     );
@@ -21030,7 +21131,8 @@ var ConsensusOracleService = class {
       walletAmount,
       lpAmount,
       yieldAmount,
-      externalAmount: walletAmount + lpAmount + yieldAmount
+      trackedPrincipalAmount: principalAmount,
+      externalAmount: walletAmount + lpAmount + principalAmount + yieldAmount
     };
   }
   // ── Settlement ───────────────────────────────────────────────────────────────
@@ -21042,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);
@@ -21100,7 +21202,8 @@ var ConsensusOracleService = class {
           const externalAmount = update ? update.externalAmount : toBigInt2(holding.externalAmount);
           const amount = localAmount + externalAmount;
           if (amount === 0n) return sum;
-          const price = update ? update.price : toBigInt2(holding.price);
+          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;
@@ -21157,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) {
@@ -21202,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(),
@@ -21213,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(),
@@ -21227,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,
@@ -21288,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perena/vault-sdk",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Vault program helpers for Bankineco integrations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",