@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/contracts/tokens/veRAAC/ragequitLock.js

@@ -4,6 +4,7 @@ exports.ragequitLock = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Ragequits a specific lock by epoch end time.
  * Initiates a ragequit process for a single lock with cooldown period and fees.
@@ -17,18 +18,16 @@ const ragequitLock = async (chainId, epochEnd, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.ragequitLock(epochEnd);
         await tx.wait();
-        console.log(`Ragequit lock initiated for epoch ${epochEnd} at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error ragequitting lock:", error);
-        throw new Error(`Failed to ragequit lock: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.ragequitLock", error, { chainId, address: contractAddress });
     }
 };
 exports.ragequitLock = ragequitLock;

package/dist/contracts/tokens/veRAAC/withdraw.js

@@ -4,6 +4,7 @@ exports.withdraw = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Withdraws expired tokens from all eligible lock positions.
  * Withdraws all expired tokens and transfers them to the caller, also claims rewards.
@@ -16,18 +17,16 @@ const withdraw = async (chainId, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.withdraw();
         await tx.wait();
-        console.log(`Withdrew expired tokens at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error withdrawing:", error);
-        throw new Error(`Failed to withdraw: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.withdraw", error, { chainId, address: contractAddress });
     }
 };
 exports.withdraw = withdraw;

package/dist/contracts/treasury/getState.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const ERC20 = ["function symbol() view returns (string)", "function decimals() view returns (uint8)", "function balanceOf(address) view returns (uint256)"];
+/**
+ * Reads every token the Treasury supports, with its tracked and actual balances. Walks `supportedTokens(i)` until the
+ * index reverts; any other error is thrown so a flaky node never returns a shortened list.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "treasury");
+    try {
+        const treasury = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("treasury"), provider);
+        const list = [];
+        for (let i = 0; i < 200; i++) {
+            try {
+                list.push(ethers_1.ethers.getAddress(await treasury.supportedTokens(i)));
+            }
+            catch (error) {
+                if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                    break;
+                throw error;
+            }
+        }
+        const tokens = await Promise.all(list.map(async (token) => {
+            const erc20 = new ethers_1.ethers.Contract(token, ERC20, provider);
+            const [symbol, decimals, tracked, held] = await Promise.all([
+                erc20.symbol().catch(() => "?"),
+                erc20.decimals().then(Number).catch(() => null),
+                treasury.getBalance(token),
+                erc20.balanceOf(address).catch(() => null),
+            ]);
+            return { address: token, symbol, decimals, tracked: (0, amount_1.toAmount)(tracked, decimals ?? 18, symbol), held: held === null ? null : (0, amount_1.toAmount)(held, decimals ?? 18, symbol) };
+        }));
+        return { tokens };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("treasury.getState", error, { chainId, address });
+    }
+}
+exports.default = getState;

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;