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

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/curve/common/getPoolState.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPoolState = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+const getPools_1 = require("./getPools");
+const COMMON = [
+    "function balances(uint256) view returns (uint256)",
+    "function totalSupply() view returns (uint256)",
+    "function get_virtual_price() view returns (uint256)",
+    "function fee() view returns (uint256)",
+    "function A() view returns (uint256)",
+];
+/**
+ * Price getters per flavour. twocrypto-ng has one price and no index; tricrypto-ng and stableswap-ng take k for
+ * coin k + 1. All price in coin 0.
+ */
+const PRICE_ABI = {
+    twocrypto: [
+        "function price_oracle() view returns (uint256)",
+        "function last_prices() view returns (uint256)",
+        "function price_scale() view returns (uint256)",
+        "function lp_price() view returns (uint256)",
+        "function mid_fee() view returns (uint256)",
+        "function out_fee() view returns (uint256)",
+    ],
+    tricrypto: [
+        "function price_oracle(uint256) view returns (uint256)",
+        "function last_prices(uint256) view returns (uint256)",
+        "function price_scale(uint256) view returns (uint256)",
+        "function lp_price() view returns (uint256)",
+        "function mid_fee() view returns (uint256)",
+        "function out_fee() view returns (uint256)",
+    ],
+    stableswap: ["function price_oracle(uint256) view returns (uint256)", "function get_p(uint256) view returns (uint256)"],
+};
+const FEE_DECIMALS = 10;
+const ONE = BigInt(10) ** BigInt(amount_1.WAD_DECIMALS);
+/**
+ * Reads a Curve pool's composition, prices and fees in one go: balances, LP supply, virtual and LP price, the
+ * oracle, spot and (crypto) scale price of every coin in coin 0, each balance's value in coin 0, and the fee and A.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The pool's state; values and TVL are in coin 0's units at the oracle price.
+ */
+const getPoolState = async (chainId, poolAddressOrId, provider) => {
+    const entry = (0, _helpers_1.resolveCurvePool)(chainId, poolAddressOrId);
+    const pool = (0, getPools_1.getPool)(chainId, entry.id);
+    if (!provider)
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    const contract = new ethers_1.ethers.Contract(entry.contract, [...COMMON, ...PRICE_ABI[entry.flavour]], provider);
+    const crypto = entry.flavour !== "stableswap";
+    const others = pool.coins.slice(1).map((_, k) => k);
+    // twocrypto-ng's price getters take no index; it has a single other coin.
+    const each = (method) => Promise.all(others.map((k) => (entry.flavour === "twocrypto" ? contract[method]() : contract[method](k))));
+    try {
+        const [balances, supply, virtualPrice, fee, A, oracle, spot, scale, lpPrice, mid, out] = await Promise.all([
+            Promise.all(pool.coins.map((_, i) => contract.balances(i))),
+            contract.totalSupply(),
+            contract.get_virtual_price(),
+            contract.fee(),
+            contract.A(),
+            each("price_oracle"),
+            each(crypto ? "last_prices" : "get_p"),
+            crypto ? each("price_scale") : Promise.resolve(null),
+            crypto ? contract.lp_price() : Promise.resolve(null),
+            crypto ? contract.mid_fee() : Promise.resolve(null),
+            crypto ? contract.out_fee() : Promise.resolve(null),
+        ]);
+        const unit = pool.coins[0];
+        const prices = (p) => [ONE, ...p].map((v) => (0, amount_1.toAmount)(v, amount_1.WAD_DECIMALS, unit.symbol));
+        const oraclePrices = prices(oracle);
+        // balance (coin decimals) * price (1e18) -> coin 0 decimals
+        const values = balances.map((b, i) => (0, amount_1.toAmount)((b * oraclePrices[i].value * BigInt(10) ** BigInt(unit.decimals)) / (BigInt(10) ** BigInt(pool.coins[i].decimals) * ONE), unit.decimals, unit.symbol));
+        const tvl = values.reduce((sum, v) => sum + v.value, BigInt(0));
+        const lp = lpPrice ?? (supply > BigInt(0) ? (tvl * BigInt(10) ** BigInt(amount_1.WAD_DECIMALS + amount_1.WAD_DECIMALS - unit.decimals)) / supply : BigInt(0));
+        return {
+            pool,
+            balances: balances.map((b, i) => (0, amount_1.toAmount)(b, pool.coins[i].decimals, pool.coins[i].symbol)),
+            totalSupply: (0, amount_1.toAmount)(supply, amount_1.WAD_DECIMALS, "LP"),
+            virtualPrice: (0, amount_1.toAmount)(virtualPrice, amount_1.WAD_DECIMALS),
+            lpPrice: (0, amount_1.toAmount)(lp, amount_1.WAD_DECIMALS, unit.symbol),
+            oraclePrices,
+            spotPrices: prices(spot),
+            priceScale: scale ? prices(scale) : null,
+            values,
+            tvl: (0, amount_1.toAmount)(tvl, unit.decimals, unit.symbol),
+            fee: (0, amount_1.toScaled)(fee, FEE_DECIMALS),
+            feeRange: mid !== null && out !== null ? { mid: (0, amount_1.toScaled)(mid, FEE_DECIMALS), out: (0, amount_1.toScaled)(out, FEE_DECIMALS) } : null,
+            A,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("curve.common.getPoolState", error, { chainId, address: entry.contract });
+    }
+};
+exports.getPoolState = getPoolState;

package/dist/contracts/curve/common/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./calcWithdrawOneCoin"), exports);
 __exportStar(require("./exchange"), exports);
 __exportStar(require("./getDy"), exports);
 __exportStar(require("./getPools"), exports);
+__exportStar(require("./getPoolState"), exports);
 __exportStar(require("./getVirtualPrice"), exports);
 __exportStar(require("./removeLiquidity"), exports);
 __exportStar(require("./removeLiquidityOneCoin"), exports);

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;