@raac/rpc 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/contracts/yearn/vault/processReport.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processReport = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const processReport = async (chainId, vaultAddressOrId, strategy, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.process_report(strategy ?? entry.contract);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.processReport", error, { chainId, address: entry.contract });
+    }
+};
+exports.processReport = processReport;

package/dist/contracts/yearn/vault/redeem.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeem = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const redeem = async (chainId, vaultAddressOrId, shares, receiver, owner, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.redeem(shares, receiver, owner);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.redeem", error, { chainId, address: entry.contract });
+    }
+};
+exports.redeem = redeem;

package/dist/contracts/yearn/vault/withdraw.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdraw = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const withdraw = async (chainId, vaultAddressOrId, assets, receiver, owner, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.withdraw(assets, receiver, owner);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.withdraw", error, { chainId, address: entry.contract });
+    }
+};
+exports.withdraw = withdraw;

package/dist/types/RPCLibrary.d.ts

@@ -160,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";
@@ -342,6 +343,9 @@ declare class RPCLibrary {
     curve: {
         common: typeof curveCommonMethods;
     };
+    yearn: {
+        vault: typeof yearnVaultMethods;
+    };
     faucet: typeof faucetMethods;
     user: typeof userMethods;
     prices: {

package/dist/types/contracts/curve/common/getPoolState.d.ts

@@ -0,0 +1,43 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { ScaledValue, TokenAmount } from "../../../utils/amount";
+import { CurvePool } from "./getPools";
+export interface CurvePoolState {
+    pool: CurvePool;
+    /** Coin balances in pool index order, each in its own decimals and symbol. */
+    balances: TokenAmount[];
+    /** LP tokens in circulation (the pool is its own LP token, 18 decimals). */
+    totalSupply: TokenAmount;
+    /** `get_virtual_price()`: underlying per LP token, only grows with fees. */
+    virtualPrice: TokenAmount;
+    /** Value of one LP token in coin 0: `lp_price()` on crypto pools, the balances at oracle prices on stableswap pools. */
+    lpPrice: TokenAmount;
+    /** Price of each coin in coin 0, 18 decimals, from the pool's EMA oracle; `oraclePrices[0]` is 1. */
+    oraclePrices: TokenAmount[];
+    /** Price of each coin in coin 0 right now: `last_prices` on crypto pools, `get_p` on stableswap pools. */
+    spotPrices: TokenAmount[];
+    /** Crypto pools only: where liquidity is concentrated (`price_scale`), in coin 0. Null on stableswap pools. */
+    priceScale: TokenAmount[] | null;
+    /** Each balance valued in coin 0 at the oracle price; their sum is the pool's TVL in coin 0. */
+    values: TokenAmount[];
+    tvl: TokenAmount;
+    /** Current swap fee as a fraction (Curve's 1e10 scale). */
+    fee: ScaledValue;
+    /** Crypto pools: the fee range the current fee moves in, as fractions. Null on stableswap pools. */
+    feeRange: {
+        mid: ScaledValue;
+        out: ScaledValue;
+    } | null;
+    /** Amplification, as the pool's `A()` reports it (crypto pools scale it by 10000). */
+    A: bigint;
+}
+/**
+ * Reads a Curve pool's composition, prices and fees in one go: balances, LP supply, virtual and LP price, the
+ * oracle, spot and (crypto) scale price of every coin in coin 0, each balance's value in coin 0, and the fee and A.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The pool's state; values and TVL are in coin 0's units at the oracle price.
+ */
+export declare const getPoolState: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<CurvePoolState>;

package/dist/types/contracts/curve/common/index.d.ts

@@ -4,6 +4,7 @@ export * from "./calcWithdrawOneCoin";
 export * from "./exchange";
 export * from "./getDy";
 export * from "./getPools";
+export * from "./getPoolState";
 export * from "./getVirtualPrice";
 export * from "./removeLiquidity";
 export * from "./removeLiquidityOneCoin";

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/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";