@raac/rpc 2.0.0-beta.15 → 2.0.0-beta.17

package/dist/nfts/getPriceStaleness.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHousePriceStale = isHousePriceStale;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../utils/contracts");
+const artifacts_1 = require("../utils/artifacts");
+const rpcError_1 = require("../utils/rpcError");
+// RAACNFT storage: token at slot 13, TRADE_FEE_PERCENTAGE at 17, PRICE_STALENESS_THRESHOLD at 18, feeCollector at 19.
+const TOKEN_SLOT = 13;
+const TRADE_FEE_SLOT = 17;
+const THRESHOLD_SLOT = 18;
+const FEE_COLLECTOR_SLOT = 19;
+/**
+ * Reads RAACNFT's `PRICE_STALENESS_THRESHOLD`, the maximum age of a house price that `mint` accepts. The variable has
+ * no getter, so it is read from storage slot 18, trusted only when the neighbouring slots match `token()`,
+ * `TRADE_FEE_PERCENTAGE()` and `feeCollector()` (the layout is as expected).
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @returns The threshold in seconds (0 turns the check off), or null when the storage layout could not be confirmed.
+ */
+async function getPriceStalenessThreshold(chainId, provider) {
+    const at = (0, contracts_1.getContractAddress)(chainId, "raacnft");
+    try {
+        const nft = new ethers_1.ethers.Contract(at, (0, artifacts_1.getABI)("raacnft"), provider);
+        const [token, tradeFee, feeCollector, ...slots] = await Promise.all([
+            nft.token(),
+            nft.TRADE_FEE_PERCENTAGE(),
+            nft.feeCollector(),
+            ...[TOKEN_SLOT, TRADE_FEE_SLOT, FEE_COLLECTOR_SLOT, THRESHOLD_SLOT].map((slot) => provider.getStorage(at, slot)),
+        ]);
+        const [tokenSlot, tradeFeeSlot, feeCollectorSlot, threshold] = slots.map((v) => BigInt(v));
+        const layoutOk = tokenSlot === BigInt(token) && tradeFeeSlot === tradeFee && feeCollectorSlot === BigInt(feeCollector);
+        return layoutOk ? Number(threshold) : null;
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("nfts.getPriceStalenessThreshold", error, { chainId, address: at });
+    }
+}
+/**
+ * Whether RAACNFT's `mint` would reject a house price as stale (`StalePriceData`), as `_validatePriceFreshness` decides:
+ * a price never set, or older than the threshold when the threshold is not 0. Only minting checks this; the lending
+ * pool's NFT adapter values collateral at the price whatever its age.
+ * @param priceTimestamp Unix seconds of the house price update; 0 when never priced.
+ * @param threshold `getPriceStalenessThreshold` in seconds.
+ * @param now Unix seconds to judge at, normally the latest block's timestamp.
+ * @returns True when a mint of this token would revert with `StalePriceData`.
+ */
+function isHousePriceStale(priceTimestamp, threshold, now) {
+    return priceTimestamp === 0 || (threshold > 0 && now > priceTimestamp + threshold);
+}
+exports.default = getPriceStalenessThreshold;

package/dist/types/RPCLibrary.d.ts

@@ -100,6 +100,7 @@ import getRawUserDepositInStabilityPool from "./pools/stabilityPool/getRawUserDe
 import getEligibleUserDeposits from "./pools/lendingPool/getEligibleUserDeposits";
 import getMintPrice from "./nfts/getMintPrice";
 import getMintFeePercentage from "./nfts/getMintFeePercentage";
+import getPriceStalenessThreshold, { isHousePriceStale } from "./nfts/getPriceStaleness";
 import getAllTokens from "./nfts/getAllTokens";
 import totalNFTSupply from "./nfts/totalNFTSupply";
 import getTokenURI from "./nfts/getTokenURI";
@@ -159,6 +160,7 @@ import * as gaugeMethods from "./contracts/governance/gauge";
 import * as controllerMethods from "./contracts/governance/gaugeController";
 import * as gaugeSystemMethods from "./contracts/governance/gaugeSystems";
 import * as curveCommonMethods from "./contracts/curve/common";
+import * as yearnVaultMethods from "./contracts/yearn/vault";
 import * as faucetMethods from "./contracts/faucet";
 import * as userMethods from "./user";
 import { cancel as cancelProposals } from "./contracts/governance/proposals/cancel";
@@ -341,6 +343,9 @@ declare class RPCLibrary {
     curve: {
         common: typeof curveCommonMethods;
     };
+    yearn: {
+        vault: typeof yearnVaultMethods;
+    };
     faucet: typeof faucetMethods;
     user: typeof userMethods;
     prices: {
@@ -379,6 +384,8 @@ declare class RPCLibrary {
         totalSupply: typeof totalNFTSupply;
         getMintPrice: typeof getMintPrice;
         getMintFeePercentage: typeof getMintFeePercentage;
+        getPriceStalenessThreshold: typeof getPriceStalenessThreshold;
+        isHousePriceStale: typeof isHousePriceStale;
         getAllTokens: typeof getAllTokens;
         getTokenURI: typeof getTokenURI;
         getTotalPropertiesCount: typeof getTotalPropertiesCount;

package/dist/types/contracts/yearn/vault/_helpers.d.ts

@@ -0,0 +1,24 @@
+import { ethers, Provider, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry, YearnVaults } from "../../../configs/chains/chain";
+/**
+ * The Yearn V3 vault surface (VaultV3.vy, API 3.0.x) these methods use. ERC4626 calls use the standard
+ * signatures: Yearn's `withdraw` defaults to a 0 max loss and `redeem` to 100%, which only matter for a vault
+ * with strategies.
+ */
+export declare const YEARN_VAULT_ABI: string[];
+/** `profitUnlockingRate` is shares per second scaled by this (VaultV3.vy `MAX_BPS_EXTENDED`). */
+export declare const PROFIT_UNLOCKING_RATE_SCALE: bigint;
+/**
+ * The APR the vault pays right now: the assets its locked profit releases per second, annualised, over total
+ * assets, as a WAD. Zero once the last reported profit has fully unlocked. It reflects the current stream only.
+ */
+export declare function aprFromUnlockingRate(contract: ethers.Contract, profitUnlockingRate: bigint, fullProfitUnlockDate: bigint, totalAssets: bigint, now: bigint): Promise<bigint>;
+export declare const getYearnVaults: (chainId: ChainId) => YearnVaults;
+/** Resolves a Yearn vault by its config key (any casing) or its address. */
+export declare function resolveYearnVault(chainId: ChainId, vaultAddressOrId: string): YearnVaultEntry;
+/** The vault contract bound to `runner`, or to the chain's default RPC when none is given. */
+export declare function getYearnVaultContract(chainId: ChainId, vaultAddressOrId: string, runner?: Provider | Signer): {
+    entry: YearnVaultEntry;
+    contract: ethers.Contract;
+};

package/dist/types/contracts/yearn/vault/deposit.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposits `assets` of the vault asset for shares. The signer approves the vault for the asset first
+ * (`wallet.assets.approveAsset(chainId, vault.asset, vault.contract, amount, signer)`).
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param receiver - Who receives the shares.
+ * @param signer - The signer sending the transaction and paying the assets.
+ * @returns The mined transaction receipt.
+ */
+export declare const deposit: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/getApr.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { ScaledValue } from "../../../utils/amount";
+/**
+ * The APR a Yearn V3 vault pays right now, from the profit still unlocking: assets released per second,
+ * annualised, over total assets. It is 0 once the last report has fully unlocked, so it reflects the current
+ * reward stream, not a historical average.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The APR as a WAD (0.05e18 = 5%).
+ */
+export declare const getApr: (chainId: ChainId, vaultAddressOrId: string, provider?: Provider) => Promise<ScaledValue>;

package/dist/types/contracts/yearn/vault/getUserInfo.d.ts

@@ -0,0 +1,29 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+export interface YearnVaultUserInfo {
+    /** Vault shares held. */
+    shares: TokenAmount;
+    /** What `shares` redeem for now, in the vault asset. */
+    assets: TokenAmount;
+    /** Wallet balance of the vault asset. */
+    assetBalance: TokenAmount;
+    /** Vault asset allowance to the vault, which `deposit` and `mint` pull from. */
+    assetAllowance: TokenAmount;
+    /** Most the user can deposit now, in the vault asset. */
+    maxDeposit: TokenAmount;
+    /** Most the user can withdraw now, in the vault asset. */
+    maxWithdraw: TokenAmount;
+    /** Most shares the user can redeem now; redeem `shares` instead for a full exit, as this can round 1 wei short. */
+    maxRedeem: TokenAmount;
+}
+/**
+ * Gets a user's position in a Yearn V3 vault, plus their vault asset balance and allowance.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section (e.g. "spmusd"), or its address.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The user's shares, their asset value, balances, allowance and limits, in base units.
+ */
+export declare function getUserInfo(chainId: ChainId, vaultAddressOrId: string, account: string, provider?: Provider): Promise<YearnVaultUserInfo>;

package/dist/types/contracts/yearn/vault/getVaultInfo.d.ts

@@ -0,0 +1,43 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry } from "../../../configs/chains/chain";
+import { ScaledValue, TokenAmount } from "../../../utils/amount";
+export interface YearnVaultInfo extends YearnVaultEntry {
+    /** Address of the vault asset. */
+    assetAddress: string;
+    apiVersion: string;
+    totalAssets: TokenAmount;
+    totalSupply: TokenAmount;
+    /** Assets held by the vault itself; all of them for a vault without strategies. */
+    totalIdle: TokenAmount;
+    /** Assets lent to strategies. */
+    totalDebt: TokenAmount;
+    /** Assets per whole share, in the vault asset's decimals. */
+    pricePerShare: ScaledValue;
+    /** Current APR from the profit still unlocking, as a WAD (0.05e18 = 5%); 0 when nothing is unlocking. */
+    apr: ScaledValue;
+    /** Reported profit not yet released to depositors, in the vault asset. */
+    lockedProfit: TokenAmount;
+    /** Seconds a reported profit takes to unlock. */
+    profitMaxUnlockTime: number;
+    /** Unix timestamp the locked profit finishes unlocking; 0 or in the past when nothing is unlocking. */
+    fullProfitUnlockDate: number;
+    /** Unix timestamp of the last report. */
+    lastProfitUpdate: number;
+    depositLimit: TokenAmount;
+    isShutdown: boolean;
+    /** Null when no accountant is set (no fees). */
+    accountant: string | null;
+    roleManager: string;
+    /** The default withdrawal queue; empty for a vault without strategies. */
+    strategies: string[];
+}
+/**
+ * Gets the vault-wide state of a Yearn V3 vault. For a user's position use `getUserInfo`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section (e.g. "spmusd"), or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault state, with amounts in base units.
+ */
+export declare function getVaultInfo(chainId: ChainId, vaultAddressOrId: string, provider?: Provider): Promise<YearnVaultInfo>;

package/dist/types/contracts/yearn/vault/getVaults.d.ts

@@ -0,0 +1,18 @@
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry } from "../../../configs/chains/chain";
+/**
+ * Lists the Yearn V3 vaults in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured vault; empty when the chain has none.
+ */
+export declare const getVaults: (chainId: ChainId) => YearnVaultEntry[];
+/**
+ * Looks up one Yearn V3 vault in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's config key or its address.
+ * @returns The vault entry.
+ * @throws If the vault is not configured on the chain.
+ */
+export declare const getVault: (chainId: ChainId, vaultAddressOrId: string) => YearnVaultEntry;

package/dist/types/contracts/yearn/vault/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./deposit";
+export * from "./getApr";
+export * from "./getUserInfo";
+export * from "./getVaultInfo";
+export * from "./getVaults";
+export * from "./mint";
+export * from "./previewDeposit";
+export * from "./previewMint";
+export * from "./previewRedeem";
+export * from "./previewWithdraw";
+export * from "./processReport";
+export * from "./redeem";
+export * from "./withdraw";

package/dist/types/contracts/yearn/vault/mint.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Mints exactly `shares`, pulling the assets they cost (see `previewMint`). The signer approves the vault for the
+ * asset first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param receiver - Who receives the shares.
+ * @param signer - The signer sending the transaction and paying the assets.
+ * @returns The mined transaction receipt.
+ */
+export declare const mint: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/previewDeposit.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Shares a deposit of `assets` would mint now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+export declare const previewDeposit: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewMint.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Assets a mint of `shares` would pull now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+export declare const previewMint: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewRedeem.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Assets a redemption of `shares` would pay out now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+export declare const previewRedeem: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/previewWithdraw.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Shares a withdrawal of `assets` would burn now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+export declare const previewWithdraw: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/yearn/vault/processReport.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Reports a strategy, or with no `strategy` the vault itself. A self-report books any vault asset sent to the vault
+ * since the last report as profit and streams it to depositors over `profitMaxUnlockTime`; this is how rewards
+ * reach a vault without strategies. The signer needs the vault's REPORTING_MANAGER role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param strategy - The strategy to report; defaults to the vault (self-report).
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const processReport: (chainId: ChainId, vaultAddressOrId: string, strategy: string | undefined, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/redeem.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Redeems `shares` for the vault asset (see `previewRedeem`). Use this, with the user's full share balance, to
+ * exit completely. Uses Yearn's default max loss of 100%, which only matters for a vault with strategies.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const redeem: (chainId: ChainId, vaultAddressOrId: string, shares: bigint, receiver: string, owner: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/withdraw.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraws exactly `assets` of the vault asset, burning the shares they cost (see `previewWithdraw`). Uses
+ * Yearn's default max loss of 0.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const withdraw: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, receiver: string, owner: string, signer: Signer) => Promise<any>;

package/dist/types/nfts/getPriceStaleness.d.ts

@@ -0,0 +1,22 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+/**
+ * Reads RAACNFT's `PRICE_STALENESS_THRESHOLD`, the maximum age of a house price that `mint` accepts. The variable has
+ * no getter, so it is read from storage slot 18, trusted only when the neighbouring slots match `token()`,
+ * `TRADE_FEE_PERCENTAGE()` and `feeCollector()` (the layout is as expected).
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @returns The threshold in seconds (0 turns the check off), or null when the storage layout could not be confirmed.
+ */
+declare function getPriceStalenessThreshold(chainId: ChainId, provider: Provider): Promise<number | null>;
+/**
+ * Whether RAACNFT's `mint` would reject a house price as stale (`StalePriceData`), as `_validatePriceFreshness` decides:
+ * a price never set, or older than the threshold when the threshold is not 0. Only minting checks this; the lending
+ * pool's NFT adapter values collateral at the price whatever its age.
+ * @param priceTimestamp Unix seconds of the house price update; 0 when never priced.
+ * @param threshold `getPriceStalenessThreshold` in seconds.
+ * @param now Unix seconds to judge at, normally the latest block's timestamp.
+ * @returns True when a mint of this token would revert with `StalePriceData`.
+ */
+export declare function isHousePriceStale(priceTimestamp: number, threshold: number, now: number): boolean;
+export default getPriceStalenessThreshold;

package/dist/types/user/computeEffectiveReturn.d.ts

@@ -1,7 +1,7 @@
 /** Whether a leg earns income or costs it. */
 export type ReturnLegKind = "earning" | "cost";
 /** What a leg earns or costs. A unit of capital earns each yield type at most once. */
-export type ReturnLegYieldType = "supply" | "gauge" | "borrow";
+export type ReturnLegYieldType = "supply" | "gauge" | "savings" | "borrow";
 /**
  * One income stream in the user's position, as {@link computeEffectiveReturn} consumes it. Adding a venue (a new
  * gauge, another pmUSD venue) only means adding a leg; the calculator does not change.
@@ -14,7 +14,7 @@ export interface ReturnLeg {
     kind: ReturnLegKind;
     yieldType: ReturnLegYieldType;
     /**
-     * True when the leg's value is money the user holds and counts towards net capital (supplied). False for the
+     * True when the leg's value is money the user holds and counts towards net capital (supplied, savings). False for the
      * debt itself, and for overlays such as a gauge, whose staked value is already counted in another leg.
      */
     countsAsCapital: boolean;
@@ -22,7 +22,7 @@ export interface ReturnLeg {
     valueUsd: number;
     /** The projected one-year rate as a fraction, e.g. 0.0077 for 0.77%. */
     rate: number;
-    /** How `rate` is quoted: "apy" when it already compounds (borrow), "apr" when it does not (supply, gauge). */
+    /** How `rate` is quoted: "apy" when it already compounds (borrow), "apr" when it does not (supply, gauge, savings). */
     rateKind: "apr" | "apy";
 }
 export interface ReturnLegWithIncome extends ReturnLeg {

package/dist/types/user/getUserPortfolio.d.ts

@@ -6,6 +6,7 @@ import { UserDebt } from "./getUserDebt";
 import { UserWalletBalances } from "./getUserWalletBalances";
 import { UserFarming } from "./getUserFarming";
 import { UserGovernance } from "./getUserGovernance";
+import { UserSavingsVault } from "./getUserSavings";
 import { Section, UsdPrices } from "./_helpers";
 export interface PortfolioCollateral {
     /** iREET deposited in the lending pool's iREET adapter. */
@@ -28,6 +29,13 @@ export interface PortfolioWallet extends UserWalletBalances {
     suppliedUsd: number;
     idleUsd: number;
 }
+export interface PortfolioSavingsVault extends UserSavingsVault {
+    valueUsd: number;
+}
+export interface PortfolioSavings {
+    vaults: PortfolioSavingsVault[];
+    valueUsd: number;
+}
 export interface UserPortfolio {
     chainId: ChainId;
     user: string;
@@ -37,6 +45,8 @@ export interface UserPortfolio {
     wallet: Section<PortfolioWallet>;
     farming: Section<UserFarming>;
     governance: Section<UserGovernance>;
+    /** Savings vault (spmUSD) positions. */
+    savings: Section<PortfolioSavings>;
     /** Collateral value + wallet RpmUSD + wallet DEpmUSD - debt, in USD. Lending pool only: LP and gauge positions are not included. */
     netPositionUsd: Section<number>;
     /** The legs the effective return is computed from; empty when any read it needs failed. */
@@ -45,7 +55,7 @@ export interface UserPortfolio {
 }
 /**
  * The user's position across the app: iREET collateral, debt and health factor, wallet RpmUSD/DEpmUSD/pmUSD, LP and
- * gauge positions, veRAAC governance power, and the projected effective return built from them. Each part is read
+ * gauge positions, savings vault positions, veRAAC governance power, and the projected effective return built from them. Each part is read
  * independently, so one failing read shows as an `error` on that part and the rest still return.
  *
  * Only the user's position data is returned; pool parameters such as the liquidation threshold stay with the callers
@@ -54,7 +64,7 @@ export interface UserPortfolio {
  * @param chainId - The chain/network to use.
  * @param user - The user's address.
  * @param prices - USD per whole token, keyed by lowercase symbol. iREET, pmUSD, RpmUSD, DEpmUSD and RAAC are needed,
- *   plus every coin of a Curve pool the user holds.
+ *   plus every coin of a Curve pool the user holds. Savings positions are valued at their asset's price (pmUSD).
  * @param provider - Optional ethers.js Provider instance. Read-only is enough.
  * @returns Each part as `{ data, error }`, the effective return legs, and the computed effective return.
  */

package/dist/types/user/getUserSavings.d.ts

@@ -0,0 +1,30 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { ScaledValue, TokenAmount } from "../utils/amount";
+export interface UserSavingsVault {
+    /** The vault's key in the chain config's `yearn` section, e.g. "spmusd". */
+    id: string;
+    name: string;
+    /** Vault (share token) address. */
+    vault: string;
+    /** Vault shares held. */
+    shares: TokenAmount;
+    /** What `shares` redeem for now, in the vault asset. */
+    assets: TokenAmount;
+    /** The vault's current APR as a WAD, from the reward still unlocking; 0 once it has all unlocked. */
+    apr: ScaledValue;
+}
+export interface UserSavings {
+    /** Every vault in the chain config's `yearn` section the user holds shares in. */
+    vaults: UserSavingsVault[];
+}
+/**
+ * The user's positions in the chain's savings vaults (the Yearn V3 vaults in the chain config, e.g. spmUSD). Vaults
+ * the user holds nothing in are left out; a chain without savings vaults returns none.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vaults the user holds, with what the shares are worth and the vault's current APR.
+ */
+export declare const getUserSavings: (chainId: ChainId, user: string, provider?: Provider) => Promise<UserSavings>;

package/dist/types/user/index.d.ts

@@ -5,5 +5,6 @@ export * from "./getUserDebt";
 export * from "./getUserFarming";
 export * from "./getUserGovernance";
 export * from "./getUserPortfolio";
+export * from "./getUserSavings";
 export * from "./getUserWalletBalances";
 export type { UsdPrices, Section } from "./_helpers";

package/dist/user/getUserPortfolio.js

@@ -14,13 +14,14 @@ const getUserDebt_1 = require("./getUserDebt");
 const getUserWalletBalances_1 = require("./getUserWalletBalances");
 const getUserFarming_1 = require("./getUserFarming");
 const getUserGovernance_1 = require("./getUserGovernance");
+const getUserSavings_1 = require("./getUserSavings");
 const _helpers_1 = require("./_helpers");
 const unavailable = (what, sections) => {
     const failed = sections.filter((section) => section.error);
     return failed.length ? new Error(`${what} needs data that could not be read: ${failed.map((section) => section.error.message).join("; ")}`) : null;
 };
 /** Builds the effective return legs from the reads. Each unit of capital earns each yield once. */
-function buildLegs(debt, rates, wallet, farming) {
+function buildLegs(debt, rates, wallet, farming, savings) {
     const legs = [];
     if (debt.valueUsd > 0) {
         legs.push({ id: "borrow", source: "Borrow pmUSD", kind: "cost", yieldType: "borrow", countsAsCapital: false, valueUsd: debt.valueUsd, rate: (0, amount_1.toNumber)(rates.borrowApy), rateKind: "apy" });
@@ -37,12 +38,16 @@ function buildLegs(debt, rates, wallet, farming) {
             continue;
         legs.push({ id: `gauge:${gauge.id}`, source: gauge.name, kind: "earning", yieldType: "gauge", countsAsCapital: false, valueUsd: gauge.valueUsd, rate: gauge.apr ?? 0, rateKind: "apr" });
     }
+    // Savings shares are pmUSD the user holds, so they count as capital; the rate is the vault's current reward stream.
+    for (const vault of savings.vaults) {
+        legs.push({ id: `savings:${vault.id}`, source: vault.name, kind: "earning", yieldType: "savings", countsAsCapital: true, valueUsd: vault.valueUsd, rate: (0, amount_1.toNumber)(vault.apr), rateKind: "apr" });
+    }
     const idleUsd = wallet.idleUsd + coins.filter((coin) => coin.yield === "none").reduce((sum, coin) => sum + coin.valueUsd, 0);
     return { legs, idleUsd };
 }
 /**
  * The user's position across the app: iREET collateral, debt and health factor, wallet RpmUSD/DEpmUSD/pmUSD, LP and
- * gauge positions, veRAAC governance power, and the projected effective return built from them. Each part is read
+ * gauge positions, savings vault positions, veRAAC governance power, and the projected effective return built from them. Each part is read
  * independently, so one failing read shows as an `error` on that part and the rest still return.
  *
  * Only the user's position data is returned; pool parameters such as the liquidation threshold stay with the callers
@@ -51,7 +56,7 @@ function buildLegs(debt, rates, wallet, farming) {
  * @param chainId - The chain/network to use.
  * @param user - The user's address.
  * @param prices - USD per whole token, keyed by lowercase symbol. iREET, pmUSD, RpmUSD, DEpmUSD and RAAC are needed,
- *   plus every coin of a Curve pool the user holds.
+ *   plus every coin of a Curve pool the user holds. Savings positions are valued at their asset's price (pmUSD).
  * @param provider - Optional ethers.js Provider instance. Read-only is enough.
  * @returns Each part as `{ data, error }`, the effective return legs, and the computed effective return.
  */
@@ -63,7 +68,7 @@ const getUserPortfolio = async (chainId, user, prices, provider) => {
         const rpc = chains_1.default[chainId].rpcs[0];
         provider = new ethers_1.ethers.JsonRpcProvider(rpc);
     }
-    const [collateral, debt, rates, wallet, farming, governance] = await Promise.all([
+    const [collateral, debt, rates, wallet, farming, governance, savings] = await Promise.all([
         (0, _helpers_1.settled)((0, getUserCollateral_1.getUserCollateral)(chainId, user, provider).then((amount) => ({ amount, valueUsd: (0, _helpers_1.requireUsd)(prices, amount, "rwaindextoken") }))),
         (0, _helpers_1.settled)((0, getUserDebt_1.getUserDebt)(chainId, user, provider).then((debt) => ({ ...debt, valueUsd: (0, _helpers_1.requireUsd)(prices, debt.amount, chains_1.default[chainId].pools.lendingpool.asset ?? "debt") }))),
         (0, _helpers_1.settled)((0, getLendingPoolInfo_1.default)(chainId, undefined, provider).then(({ borrowRate, borrowApy, supplyApy }) => ({ borrowRate, borrowApy, supplyApy }))),
@@ -74,6 +79,10 @@ const getUserPortfolio = async (chainId, user, prices, provider) => {
         }))),
         (0, _helpers_1.settled)((0, getUserFarming_1.getUserFarming)(chainId, user, prices, provider)),
         (0, _helpers_1.settled)((0, getUserGovernance_1.getUserGovernance)(chainId, user, provider)),
+        (0, _helpers_1.settled)((0, getUserSavings_1.getUserSavings)(chainId, user, provider).then((read) => {
+            const vaults = read.vaults.map((vault) => ({ ...vault, valueUsd: (0, _helpers_1.requireUsd)(prices, vault.assets, vault.id) }));
+            return { vaults, valueUsd: vaults.reduce((sum, vault) => sum + vault.valueUsd, 0) };
+        })),
     ]);
     const netPositionError = unavailable("Net RAACLend position", [collateral, debt, wallet]);
     const netPositionUsd = netPositionError
@@ -83,12 +92,12 @@ const getUserPortfolio = async (chainId, user, prices, provider) => {
     const farmingErrors = (farming.data?.errors ?? []).map(({ pool, error }) => ({ data: null, error: new Error(`Curve pool ${pool}: ${error.message}`) }));
     let legs = [];
     let effectiveReturn;
-    const returnError = unavailable("Effective return", [collateral, debt, rates, wallet, farming, ...farmingErrors]);
+    const returnError = unavailable("Effective return", [collateral, debt, rates, wallet, farming, savings, ...farmingErrors]);
     if (returnError) {
         effectiveReturn = { data: null, error: returnError };
     }
     else {
-        const built = buildLegs(debt.data, rates.data, wallet.data, farming.data);
+        const built = buildLegs(debt.data, rates.data, wallet.data, farming.data, savings.data);
         legs = built.legs;
         effectiveReturn = { data: (0, computeEffectiveReturn_1.computeEffectiveReturn)({ legs, collateralUsd: collateral.data.valueUsd, idleUsd: built.idleUsd }), error: null };
     }
@@ -101,6 +110,7 @@ const getUserPortfolio = async (chainId, user, prices, provider) => {
         wallet,
         farming,
         governance,
+        savings,
         netPositionUsd,
         legs,
         effectiveReturn,

package/dist/user/getUserSavings.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserSavings = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const getApr_1 = require("../contracts/yearn/vault/getApr");
+const getUserInfo_1 = require("../contracts/yearn/vault/getUserInfo");
+const getVaults_1 = require("../contracts/yearn/vault/getVaults");
+/**
+ * The user's positions in the chain's savings vaults (the Yearn V3 vaults in the chain config, e.g. spmUSD). Vaults
+ * the user holds nothing in are left out; a chain without savings vaults returns none.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vaults the user holds, with what the shares are worth and the vault's current APR.
+ */
+const getUserSavings = async (chainId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const held = await Promise.all((0, getVaults_1.getVaults)(chainId).map(async (entry) => {
+        const info = await (0, getUserInfo_1.getUserInfo)(chainId, entry.contract, user, provider);
+        if (info.shares.value === 0n)
+            return null;
+        const apr = await (0, getApr_1.getApr)(chainId, entry.contract, provider);
+        return { id: entry.id, name: entry.name, vault: entry.contract, shares: info.shares, assets: info.assets, apr };
+    }));
+    return { vaults: held.filter((vault) => vault !== null) };
+};
+exports.getUserSavings = getUserSavings;