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

package/dist/RPCLibrary.js

@@ -158,6 +158,7 @@ const getRawUserDepositsInStabilityPool_1 = __importDefault(require("./pools/sta
 const getEligibleUserDeposits_1 = __importDefault(require("./pools/lendingPool/getEligibleUserDeposits"));
 const getMintPrice_1 = __importDefault(require("./nfts/getMintPrice"));
 const getMintFeePercentage_1 = __importDefault(require("./nfts/getMintFeePercentage"));
+const getPriceStaleness_1 = __importStar(require("./nfts/getPriceStaleness"));
 const getAllTokens_1 = __importDefault(require("./nfts/getAllTokens"));
 const totalNFTSupply_1 = __importDefault(require("./nfts/totalNFTSupply"));
 const getTokenURI_1 = __importDefault(require("./nfts/getTokenURI"));
@@ -225,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"));
@@ -426,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;
@@ -497,6 +501,8 @@ class RPCLibrary {
             totalSupply: totalNFTSupply_1.default,
             getMintPrice: getMintPrice_1.default,
             getMintFeePercentage: getMintFeePercentage_1.default,
+            getPriceStalenessThreshold: getPriceStaleness_1.default,
+            isHousePriceStale: getPriceStaleness_1.isHousePriceStale,
             getAllTokens: getAllTokens_1.default,
             getTokenURI: getTokenURI_1.default,
             getTotalPropertiesCount: getTotalPropertiesCount_1.default,
@@ -915,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;