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

package/dist/RPCLibrary.js

@@ -226,6 +226,7 @@ const controllerMethods = __importStar(require("./contracts/governance/gaugeCont
 const gaugeSystemMethods = __importStar(require("./contracts/governance/gaugeSystems"));
 // ===== Curve =====
 const curveCommonMethods = __importStar(require("./contracts/curve/common"));
+const yearnVaultMethods = __importStar(require("./contracts/yearn/vault"));
 const faucetMethods = __importStar(require("./contracts/faucet"));
 // ===== User aggregates (dashboard) =====
 const userMethods = __importStar(require("./user"));
@@ -427,6 +428,8 @@ class RPCLibrary {
     // prices
     // Curve pools from the chain config's `curve` section
     curve;
+    // Yearn V3 vaults from the chain config's `yearn` section
+    yearn;
     faucet;
     // Aggregate reads of one user's position and claimables, composed from the methods above
     user;
@@ -918,6 +921,9 @@ class RPCLibrary {
         this.curve = {
             common: curveCommonMethods,
         };
+        this.yearn = {
+            vault: yearnVaultMethods,
+        };
         this.faucet = faucetMethods;
         this.user = userMethods;
         this.prices = {

package/dist/configs/chains/11155111.json

@@ -253,6 +253,14 @@
             "coins": ["pmusd", "raactoken", "leraac"]
         }
     },
+    "yearn": {
+        "spmusd": {
+            "id": "spmusd",
+            "name": "Savings pmUSD",
+            "contract": "0xAC7Db048FB762Dbe714aDE6D3903E6Dd992690a5",
+            "asset": "pmusd"
+        }
+    },
     "nfts": {
         "raacnft": {
             "id": "raacnft",
@@ -295,6 +303,13 @@
             "decimals": 18,
             "contract": "0x0D63FFffF740A0B5DbcC6C70774FDA1456195a3c"
         },
+        "spmusd": {
+            "id": "spmusd",
+            "name": "Savings pmUSD",
+            "symbol": "spmUSD",
+            "decimals": 18,
+            "contract": "0xAC7Db048FB762Dbe714aDE6D3903E6Dd992690a5"
+        },
         "usdc": {
             "id": "usdc",
             "name": "USDC",

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

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getYearnVaults = exports.PROFIT_UNLOCKING_RATE_SCALE = exports.YEARN_VAULT_ABI = void 0;
+exports.aprFromUnlockingRate = aprFromUnlockingRate;
+exports.resolveYearnVault = resolveYearnVault;
+exports.getYearnVaultContract = getYearnVaultContract;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+/**
+ * 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.
+ */
+exports.YEARN_VAULT_ABI = [
+    "function asset() view returns (address)",
+    "function decimals() view returns (uint8)",
+    "function apiVersion() view returns (string)",
+    "function totalAssets() view returns (uint256)",
+    "function totalSupply() view returns (uint256)",
+    "function totalIdle() view returns (uint256)",
+    "function totalDebt() view returns (uint256)",
+    "function pricePerShare() view returns (uint256)",
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function convertToAssets(uint256 shares) view returns (uint256)",
+    "function convertToShares(uint256 assets) view returns (uint256)",
+    "function previewDeposit(uint256 assets) view returns (uint256)",
+    "function previewMint(uint256 shares) view returns (uint256)",
+    "function previewWithdraw(uint256 assets) view returns (uint256)",
+    "function previewRedeem(uint256 shares) view returns (uint256)",
+    "function maxDeposit(address receiver) view returns (uint256)",
+    "function maxWithdraw(address owner) view returns (uint256)",
+    "function maxRedeem(address owner) view returns (uint256)",
+    "function profitMaxUnlockTime() view returns (uint256)",
+    "function fullProfitUnlockDate() view returns (uint256)",
+    "function profitUnlockingRate() view returns (uint256)",
+    "function lastProfitUpdate() view returns (uint256)",
+    "function unlockedShares() view returns (uint256)",
+    "function deposit_limit() view returns (uint256)",
+    "function isShutdown() view returns (bool)",
+    "function accountant() view returns (address)",
+    "function role_manager() view returns (address)",
+    "function roles(address) view returns (uint256)",
+    "function get_default_queue() view returns (address[])",
+    "function deposit(uint256 assets, address receiver) returns (uint256)",
+    "function mint(uint256 shares, address receiver) returns (uint256)",
+    "function withdraw(uint256 assets, address receiver, address owner) returns (uint256)",
+    "function redeem(uint256 shares, address receiver, address owner) returns (uint256)",
+    "function process_report(address strategy) returns (uint256, uint256)",
+];
+/** `profitUnlockingRate` is shares per second scaled by this (VaultV3.vy `MAX_BPS_EXTENDED`). */
+exports.PROFIT_UNLOCKING_RATE_SCALE = 10n ** 12n;
+const SECONDS_PER_YEAR = 365n * 24n * 60n * 60n;
+/**
+ * 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.
+ */
+async function aprFromUnlockingRate(contract, profitUnlockingRate, fullProfitUnlockDate, totalAssets, now) {
+    if (fullProfitUnlockDate <= now || profitUnlockingRate === 0n || totalAssets === 0n)
+        return 0n;
+    const sharesPerYear = (profitUnlockingRate * SECONDS_PER_YEAR) / exports.PROFIT_UNLOCKING_RATE_SCALE;
+    const assetsPerYear = await contract.convertToAssets(sharesPerYear);
+    return (assetsPerYear * 10n ** 18n) / totalAssets;
+}
+const getYearnVaults = (chainId) => chains_1.default[chainId]?.yearn ?? {};
+exports.getYearnVaults = getYearnVaults;
+/** Resolves a Yearn vault by its config key (any casing) or its address. */
+function resolveYearnVault(chainId, vaultAddressOrId) {
+    const vaults = (0, exports.getYearnVaults)(chainId);
+    const needle = vaultAddressOrId.toLowerCase();
+    const entry = vaults[needle] ?? Object.values(vaults).find((vault) => vault.contract.toLowerCase() === needle);
+    if (!entry)
+        throw new Error(`Yearn vault "${vaultAddressOrId}" not configured for chain ${chainId}`);
+    return entry;
+}
+/** The vault contract bound to `runner`, or to the chain's default RPC when none is given. */
+function getYearnVaultContract(chainId, vaultAddressOrId, runner) {
+    const entry = resolveYearnVault(chainId, vaultAddressOrId);
+    if (!runner) {
+        runner = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    }
+    return { entry, contract: new ethers_1.ethers.Contract(entry.contract, exports.YEARN_VAULT_ABI, runner) };
+}

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApr = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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%).
+ */
+const getApr = async (chainId, vaultAddressOrId, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        const [profitUnlockingRate, fullProfitUnlockDate, totalAssets, block] = await Promise.all([
+            contract.profitUnlockingRate(),
+            contract.fullProfitUnlockDate(),
+            contract.totalAssets(),
+            contract.runner.provider.getBlock("latest"),
+        ]);
+        if (!block)
+            throw new Error("Latest block unavailable");
+        return (0, amount_1.toScaled)(await (0, _helpers_1.aprFromUnlockingRate)(contract, profitUnlockingRate, fullProfitUnlockDate, totalAssets, BigInt(block.timestamp)));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.getApr", error, { chainId, address: entry.contract });
+    }
+};
+exports.getApr = getApr;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserInfo = getUserInfo;
+const ethers_1 = require("ethers");
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+const ERC20_READ_ABI = [
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+];
+/**
+ * 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.
+ */
+async function getUserInfo(chainId, vaultAddressOrId, account, provider) {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    const asset = (value) => (0, amount_1.toTokenAmount)(chainId, entry.asset, value);
+    const shares = (value) => (0, amount_1.toTokenAmount)(chainId, entry.contract, value);
+    try {
+        const token = new ethers_1.ethers.Contract(await contract.asset(), ERC20_READ_ABI, contract.runner);
+        const [userShares, assetBalance, assetAllowance, maxDeposit, maxWithdraw, maxRedeem] = await Promise.all([
+            contract.balanceOf(account),
+            token.balanceOf(account),
+            token.allowance(account, entry.contract),
+            contract.maxDeposit(account),
+            contract.maxWithdraw(account),
+            contract.maxRedeem(account),
+        ]);
+        return {
+            shares: shares(userShares),
+            assets: asset(await contract.convertToAssets(userShares)),
+            assetBalance: asset(assetBalance),
+            assetAllowance: asset(assetAllowance),
+            maxDeposit: asset(maxDeposit),
+            maxWithdraw: asset(maxWithdraw),
+            maxRedeem: shares(maxRedeem),
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.getUserInfo", error, { chainId, address: entry.contract });
+    }
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaultInfo = getVaultInfo;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+ * 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.
+ */
+async function getVaultInfo(chainId, vaultAddressOrId, provider) {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    const asset = (value) => (0, amount_1.toTokenAmount)(chainId, entry.asset, value);
+    const shares = (value) => (0, amount_1.toTokenAmount)(chainId, entry.contract, value);
+    try {
+        const [assetAddress, apiVersion, totalAssets, totalSupply, totalIdle, totalDebt, pricePerShare, lockedShares, profitMaxUnlockTime, fullProfitUnlockDate, profitUnlockingRate, lastProfitUpdate, depositLimit, isShutdown, accountant, roleManager, strategies, block,] = await Promise.all([
+            contract.asset(),
+            contract.apiVersion(),
+            contract.totalAssets(),
+            contract.totalSupply(),
+            contract.totalIdle(),
+            contract.totalDebt(),
+            contract.pricePerShare(),
+            contract.balanceOf(entry.contract),
+            contract.profitMaxUnlockTime(),
+            contract.fullProfitUnlockDate(),
+            contract.profitUnlockingRate(),
+            contract.lastProfitUpdate(),
+            contract.deposit_limit(),
+            contract.isShutdown(),
+            contract.accountant(),
+            contract.role_manager(),
+            contract.get_default_queue(),
+            contract.runner.provider.getBlock("latest"),
+        ]);
+        if (!block)
+            throw new Error("Latest block unavailable");
+        const [lockedProfit, apr] = await Promise.all([
+            contract.convertToAssets(lockedShares),
+            (0, _helpers_1.aprFromUnlockingRate)(contract, profitUnlockingRate, fullProfitUnlockDate, totalAssets, BigInt(block.timestamp)),
+        ]);
+        return {
+            ...entry,
+            assetAddress,
+            apiVersion,
+            totalAssets: asset(totalAssets),
+            totalSupply: shares(totalSupply),
+            totalIdle: asset(totalIdle),
+            totalDebt: asset(totalDebt),
+            pricePerShare: (0, amount_1.toScaled)(pricePerShare, (0, amount_1.getAssetDecimals)(chainId, entry.asset)),
+            apr: (0, amount_1.toScaled)(apr),
+            lockedProfit: asset(lockedProfit),
+            profitMaxUnlockTime: Number(profitMaxUnlockTime),
+            fullProfitUnlockDate: Number(fullProfitUnlockDate),
+            lastProfitUpdate: Number(lastProfitUpdate),
+            depositLimit: asset(depositLimit),
+            isShutdown,
+            accountant: accountant === ZERO_ADDRESS ? null : accountant,
+            roleManager,
+            strategies: [...strategies],
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.getVaultInfo", error, { chainId, address: entry.contract });
+    }
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVault = exports.getVaults = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const getVaults = (chainId) => Object.values((0, _helpers_1.getYearnVaults)(chainId));
+exports.getVaults = getVaults;
+/**
+ * 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.
+ */
+const getVault = (chainId, vaultAddressOrId) => (0, _helpers_1.resolveYearnVault)(chainId, vaultAddressOrId);
+exports.getVault = getVault;

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

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./deposit"), exports);
+__exportStar(require("./getApr"), exports);
+__exportStar(require("./getUserInfo"), exports);
+__exportStar(require("./getVaultInfo"), exports);
+__exportStar(require("./getVaults"), exports);
+__exportStar(require("./mint"), exports);
+__exportStar(require("./previewDeposit"), exports);
+__exportStar(require("./previewMint"), exports);
+__exportStar(require("./previewRedeem"), exports);
+__exportStar(require("./previewWithdraw"), exports);
+__exportStar(require("./processReport"), exports);
+__exportStar(require("./redeem"), exports);
+__exportStar(require("./withdraw"), exports);

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewDeposit = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const previewDeposit = async (chainId, vaultAddressOrId, assets, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.contract, await contract.previewDeposit(assets));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewDeposit", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewDeposit = previewDeposit;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewMint = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const previewMint = async (chainId, vaultAddressOrId, shares, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.asset, await contract.previewMint(shares));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewMint", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewMint = previewMint;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewRedeem = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const previewRedeem = async (chainId, vaultAddressOrId, shares, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.asset, await contract.previewRedeem(shares));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewRedeem", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewRedeem = previewRedeem;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewWithdraw = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+const previewWithdraw = async (chainId, vaultAddressOrId, assets, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.contract, await contract.previewWithdraw(assets));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewWithdraw", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewWithdraw = previewWithdraw;

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

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;

package/dist/user/index.js

@@ -21,4 +21,5 @@ __exportStar(require("./getUserDebt"), exports);
 __exportStar(require("./getUserFarming"), exports);
 __exportStar(require("./getUserGovernance"), exports);
 __exportStar(require("./getUserPortfolio"), exports);
+__exportStar(require("./getUserSavings"), exports);
 __exportStar(require("./getUserWalletBalances"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.16",
+	"version": "2.0.0-beta.17",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",