@raac/rpc 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/user/getUserClaimables.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserClaimables = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const contracts_1 = require("../utils/contracts");
+const getContractAddress_1 = require("../contracts/getContractAddress");
+const getGauges_1 = require("../contracts/governance/gaugeSystems/getGauges");
+const getUserClaimableRewards_1 = require("../contracts/governance/gauge/getUserClaimableRewards");
+const getRewardTokens_1 = require("../contracts/tokens/veRAAC/getRewardTokens");
+const getMaxUnclaimedDistributions_1 = require("../contracts/tokens/veRAAC/getMaxUnclaimedDistributions");
+const getClaimable_1 = require("../contracts/tokens/veRAAC/getClaimable");
+const getUserInfo_1 = require("../contracts/lockers/maturityVault/getUserInfo");
+const getClaimables_1 = require("../contracts/lockers/botLocker/getClaimables");
+const _helpers_1 = require("./_helpers");
+const toSource = (tokens) => ({ available: true, tokens: tokens.filter(({ amount }) => amount.value > 0n), error: null });
+const failed = (error, available = true) => ({ available, tokens: [], error });
+/** A locker's address when the chain config has it deployed; null when the chain has none. */
+function deployedLocker(chainId, name) {
+    const lockers = chains_1.default[chainId].lockers;
+    const address = lockers?.[name]?.contract;
+    return (0, contracts_1.isDeployed)(address) ? address : null;
+}
+async function readVeRAAC(chainId, user, provider) {
+    const rewardTokens = await (0, getRewardTokens_1.getRewardTokens)(chainId, provider);
+    return Promise.all(rewardTokens.map(async (token) => {
+        const maxDistributions = await (0, getMaxUnclaimedDistributions_1.getMaxUnclaimedDistributions)(chainId, user, token, provider);
+        const amount = await (0, getClaimable_1.getClaimable)(chainId, user, token, maxDistributions, provider);
+        return { token, amount };
+    }));
+}
+/**
+ * Everything a user can claim right now, across gauges, veRAAC fees, the maturity vault and the bot locker. Amounts
+ * only: the caller values them in USD with its own prices. Each source (and each gauge) is read independently, so one
+ * failing read shows as an error on that source and every other source still returns.
+ *
+ * Every configured gauge is scanned, not only those the user is staked in: a user can still have rewards after fully
+ * unstaking.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Per source: the non-zero claimable tokens, and an `error` when it failed.
+ */
+const getUserClaimables = async (chainId, user, provider) => {
+    if (!ethers_1.ethers.isAddress(user)) {
+        throw new Error(`Invalid user address: ${user}`);
+    }
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const gauges = (0, getGauges_1.getGauges)(chainId).filter((gauge) => (0, contracts_1.isDeployed)(gauge.contract));
+    const maturityVault = deployedLocker(chainId, "raacmaturityvault");
+    const botLocker = deployedLocker(chainId, "raacbotlocker");
+    const [gaugeResults, veRAACResult, maturityResult, botResult] = await Promise.all([
+        Promise.all(gauges.map((gauge) => (0, _helpers_1.settled)((0, getUserClaimableRewards_1.getUserClaimableRewards)(chainId, gauge.contract, user, provider)))),
+        (0, _helpers_1.settled)(readVeRAAC(chainId, user, provider)),
+        maturityVault ? (0, _helpers_1.settled)((0, getUserInfo_1.getUserInfo)(chainId, user, provider)) : null,
+        botLocker ? (0, _helpers_1.settled)((0, getClaimables_1.getClaimables)(chainId, user, provider)) : null,
+    ]);
+    const items = gauges.map((gauge, i) => {
+        const result = gaugeResults[i];
+        const base = { gauge: gauge.contract, id: gauge.id, name: gauge.name, system: gauge.system };
+        if (result.error)
+            return { ...base, ...failed(result.error) };
+        const { rewardToken, inGauge, extras } = result.data;
+        return { ...base, ...toSource([{ token: rewardToken, amount: inGauge }, ...extras.map(({ token, amount }) => ({ token, amount }))]) };
+    });
+    const gaugeErrors = items.filter((item) => item.error).map((item) => item.error);
+    const gaugesSource = {
+        available: items.length > 0,
+        tokens: items.flatMap((item) => item.tokens),
+        error: gaugeErrors.length > 1 ? new Error(`${gaugeErrors.length} gauges could not be read`) : (gaugeErrors[0] ?? null),
+        items,
+        claimableCount: items.filter((item) => item.tokens.length > 0).length,
+    };
+    const veRAAC = veRAACResult.error ? failed(veRAACResult.error) : toSource(veRAACResult.data);
+    const maturity = !maturityResult
+        ? failed(null, false)
+        : maturityResult.error
+            ? failed(maturityResult.error)
+            : toSource([{ token: (0, getContractAddress_1.getContractAddress)(chainId, "raactoken"), amount: maturityResult.data.realised }]);
+    const bot = !botResult ? failed(null, false) : botResult.error ? failed(botResult.error) : toSource(botResult.data);
+    return {
+        chainId,
+        user: ethers_1.ethers.getAddress(user),
+        gauges: gaugesSource,
+        veRAAC,
+        maturityVault: maturity,
+        botLocker: bot,
+    };
+};
+exports.getUserClaimables = getUserClaimables;

package/dist/user/getUserCollateral.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserCollateral = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const getAdapterAddress_1 = require("../pools/lendingPool/getAdapterAddress");
+const getERC20AdapterBalance_1 = __importDefault(require("../pools/lendingPool/adapters/erc20/getERC20AdapterBalance"));
+/**
+ * The iREET a user has deposited as collateral in the lending pool's iREET adapter. NFT collateral is not included.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The deposited iREET, with its registry decimals and symbol.
+ */
+const getUserCollateral = async (chainId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const adapter = (0, getAdapterAddress_1.getAdapterAddressOnly)(chainId, "rwaindextokenadapter");
+    if (!adapter)
+        throw new Error("The iREET adapter is not configured on this chain");
+    return (0, getERC20AdapterBalance_1.default)(chainId, adapter, user, provider);
+};
+exports.getUserCollateral = getUserCollateral;

package/dist/user/getUserDebt.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserDebt = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const getPositionView_1 = __importDefault(require("../pools/lendingPool/getPositionView"));
+/** Position data of the single iREET position: the ERC20 adapter keys it by `abi.encode(uint256(0))`. */
+const IREET_POSITION_DATA = ethers_1.AbiCoder.defaultAbiCoder().encode(["uint256"], [0]);
+/** The lending pool's health factor for a position with no debt (1e27). Scaled as WAD otherwise. */
+const NO_DEBT_HEALTH_FACTOR = 10n ** 27n;
+/**
+ * The debt and health factor of a user's iREET position in the lending pool.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The debt, and the health factor when there is debt.
+ */
+const getUserDebt = async (chainId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const view = await (0, getPositionView_1.default)(chainId, "rwaindextokenadapter", user, IREET_POSITION_DATA, provider);
+    const amount = view.scaledDebtBalance;
+    const hasDebt = amount.value > 0n && view.healthFactor.value < NO_DEBT_HEALTH_FACTOR;
+    return { amount, healthFactor: hasDebt ? view.healthFactor : null };
+};
+exports.getUserDebt = getUserDebt;

package/dist/user/getUserFarming.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserFarming = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const amount_1 = require("../utils/amount");
+const contracts_1 = require("../utils/contracts");
+const getRawBalanceOf_1 = require("../contracts/governance/gauge/getRawBalanceOf");
+const getUserApy_1 = require("../contracts/governance/gauge/getUserApy");
+const getGauges_1 = require("../contracts/governance/gaugeSystems/getGauges");
+const _helpers_1 = require("../contracts/curve/common/_helpers");
+const _helpers_2 = require("./_helpers");
+/** The lending pool's receipts earn the supply rate wherever they sit; no other coin earns on its own. */
+const coinYield = (asset) => (asset === "rtoken" || asset === "detoken" ? "supply" : "none");
+/** Every registered asset's price keyed by address, as `getUserApy` takes reward token prices. */
+function pricesByAddress(chainId, prices) {
+    const assets = (chains_1.default[chainId]?.assets ?? {});
+    const byAddress = {};
+    for (const { contract, symbol } of Object.values(assets)) {
+        const price = symbol === undefined ? undefined : prices[symbol.toLowerCase()];
+        if (contract && typeof price === "number" && Number.isFinite(price))
+            byAddress[contract.toLowerCase()] = price;
+    }
+    return byAddress;
+}
+async function readPool(chainId, user, entry, gauges, prices, rewardTokenPricesUSD, provider) {
+    const contract = new ethers_1.ethers.Contract(entry.contract, _helpers_1.CURVE_POOL_READ_ABI, provider);
+    const [walletLp, staked] = await Promise.all([
+        contract.balanceOf(user),
+        Promise.all(gauges.map((gauge) => (0, getRawBalanceOf_1.getRawBalanceOf)(chainId, gauge.contract, user, provider))),
+    ]);
+    const stakedLp = staked.reduce((sum, amount) => sum + amount.value, 0n);
+    const userLp = walletLp + stakedLp;
+    // Pool reserves and prices are only needed when the user holds some of the pool's LP.
+    let coins = [];
+    let lpPriceUsd = 0;
+    if (userLp > 0n) {
+        const [totalSupply, ...balances] = (await Promise.all([
+            contract.totalSupply(),
+            ...entry.coins.map((_, i) => contract.balances(i)),
+        ]));
+        coins = entry.coins.map((asset, i) => {
+            const amount = (0, amount_1.toTokenAmount)(chainId, asset, (balances[i] * userLp) / totalSupply);
+            return { asset, amount, valueUsd: (0, _helpers_2.requireUsd)(prices, amount, asset), yield: coinYield(asset) };
+        });
+        lpPriceUsd = coins.reduce((sum, coin) => sum + coin.valueUsd, 0) / (0, amount_1.toNumber)((0, amount_1.toAmount)(userLp, amount_1.WAD_DECIMALS));
+    }
+    const farmed = await Promise.all(gauges.map(async (gauge, i) => {
+        let apr = null;
+        if (staked[i].value > 0n) {
+            const apy = await (0, getUserApy_1.getUserApy)(chainId, gauge.contract, user, { stakingTokenPriceUSD: lpPriceUsd, rewardTokenPricesUSD }, {}, provider);
+            // getUserApy reports simple annualized percent, not compounded: an APR.
+            apr = apy.current.apy === null ? null : apy.current.apy / 100;
+        }
+        return { id: gauge.id, gauge: gauge.contract, name: gauge.name, pool: entry.id, staked: staked[i], valueUsd: (0, amount_1.toNumber)(staked[i]) * lpPriceUsd, apr };
+    }));
+    return {
+        pool: { pool: entry.id, address: entry.contract, walletLp: (0, amount_1.toAmount)(walletLp, amount_1.WAD_DECIMALS), stakedLp: (0, amount_1.toAmount)(stakedLp, amount_1.WAD_DECIMALS), coins },
+        gauges: farmed,
+    };
+}
+/**
+ * A user's Curve LP and gauge positions: every configured Curve pool that a configured gauge stakes, the user's share
+ * of each pool's coins, and their stake and boosted APR in each gauge. Each pool is read independently, so one failing
+ * pool shows in `errors` and the rest still return. Reserves, prices and APRs are only read for pools the user holds.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param prices - USD per whole token, keyed by lowercase symbol. Needs every coin of a pool the user holds, and the
+ *   reward tokens of a gauge the user is staked in.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The pools and gauges read, and the pools that failed.
+ */
+const getUserFarming = async (chainId, user, prices, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const gauges = (0, getGauges_1.getGauges)(chainId).filter((gauge) => (0, contracts_1.isDeployed)(gauge.contract) && gauge.stakingToken);
+    const farmed = Object.values((0, _helpers_1.getCurvePools)(chainId))
+        .map((pool) => ({ pool, gauges: gauges.filter((gauge) => gauge.stakingToken.toLowerCase() === pool.contract.toLowerCase()) }))
+        .filter((entry) => entry.gauges.length > 0);
+    const rewardTokenPricesUSD = pricesByAddress(chainId, prices);
+    const results = await Promise.all(farmed.map((entry) => (0, _helpers_2.settled)(readPool(chainId, user, entry.pool, entry.gauges, prices, rewardTokenPricesUSD, provider))));
+    const farming = { pools: [], gauges: [], errors: [] };
+    results.forEach((result, i) => {
+        if (result.error) {
+            farming.errors.push({ pool: farmed[i].pool.id, error: result.error });
+        }
+        else {
+            farming.pools.push(result.data.pool);
+            farming.gauges.push(...result.data.gauges);
+        }
+    });
+    return farming;
+};
+exports.getUserFarming = getUserFarming;

package/dist/user/getUserGovernance.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserGovernance = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const amount_1 = require("../utils/amount");
+const getContractAddress_1 = require("../contracts/getContractAddress");
+const getBalance_1 = require("../contracts/tokens/veRAAC/getBalance");
+const getTotalSupply_1 = require("../contracts/tokens/veRAAC/getTotalSupply");
+const getLockedBalance_1 = require("../contracts/tokens/veRAAC/getLockedBalance");
+/**
+ * A user's veRAAC governance position: voting power, its share of the total, and the RAAC locked.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The voting power, total voting power, share and locked RAAC.
+ */
+const getUserGovernance = async (chainId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const [votingPower, totalVotingPower, locked] = await Promise.all([
+        (0, getBalance_1.getBalance)(chainId, user, provider),
+        (0, getTotalSupply_1.getTotalSupply)(chainId, (0, getContractAddress_1.getContractAddress)(chainId, "veraac"), provider),
+        (0, getLockedBalance_1.getLockedBalance)(chainId, user, provider),
+    ]);
+    const total = (0, amount_1.toNumber)(totalVotingPower);
+    return { votingPower, totalVotingPower, share: total > 0 ? (0, amount_1.toNumber)(votingPower) / total : null, locked };
+};
+exports.getUserGovernance = getUserGovernance;

package/dist/user/getUserPortfolio.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserPortfolio = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const amount_1 = require("../utils/amount");
+const getLendingPoolInfo_1 = __importDefault(require("../pools/lendingPool/getLendingPoolInfo"));
+const computeEffectiveReturn_1 = require("./computeEffectiveReturn");
+const getUserCollateral_1 = require("./getUserCollateral");
+const getUserDebt_1 = require("./getUserDebt");
+const getUserWalletBalances_1 = require("./getUserWalletBalances");
+const getUserFarming_1 = require("./getUserFarming");
+const getUserGovernance_1 = require("./getUserGovernance");
+const _helpers_1 = require("./_helpers");
+const unavailable = (what, sections) => {
+    const failed = sections.filter((section) => section.error);
+    return failed.length ? new Error(`${what} needs data that could not be read: ${failed.map((section) => section.error.message).join("; ")}`) : null;
+};
+/** Builds the effective return legs from the reads. Each unit of capital earns each yield once. */
+function buildLegs(debt, rates, wallet, farming) {
+    const legs = [];
+    if (debt.valueUsd > 0) {
+        legs.push({ id: "borrow", source: "Borrow pmUSD", kind: "cost", yieldType: "borrow", countsAsCapital: false, valueUsd: debt.valueUsd, rate: (0, amount_1.toNumber)(rates.borrowApy), rateKind: "apy" });
+    }
+    // Every RpmUSD and DEpmUSD the user owns earns the supply rate wherever it sits: the wallet, inside an LP, or LP staked in a gauge.
+    const coins = farming.pools.flatMap((pool) => pool.coins);
+    const suppliedUsd = wallet.suppliedUsd + coins.filter((coin) => coin.yield === "supply").reduce((sum, coin) => sum + coin.valueUsd, 0);
+    if (suppliedUsd > 0) {
+        legs.push({ id: "supply", source: "Supplied (RpmUSD + DEpmUSD)", kind: "earning", yieldType: "supply", countsAsCapital: true, valueUsd: suppliedUsd, rate: (0, amount_1.toNumber)(rates.supplyApy), rateKind: "apr" });
+    }
+    // A gauge is an overlay: its staked value is already counted through its coins, so it earns rewards but adds no capital.
+    for (const gauge of farming.gauges) {
+        if (gauge.staked.value === 0n)
+            continue;
+        legs.push({ id: `gauge:${gauge.id}`, source: gauge.name, kind: "earning", yieldType: "gauge", countsAsCapital: false, valueUsd: gauge.valueUsd, rate: gauge.apr ?? 0, rateKind: "apr" });
+    }
+    const idleUsd = wallet.idleUsd + coins.filter((coin) => coin.yield === "none").reduce((sum, coin) => sum + coin.valueUsd, 0);
+    return { legs, idleUsd };
+}
+/**
+ * The user's position across the app: iREET collateral, debt and health factor, wallet RpmUSD/DEpmUSD/pmUSD, LP and
+ * gauge positions, veRAAC governance power, and the projected effective return built from them. Each part is read
+ * independently, so one failing read shows as an `error` on that part and the rest still return.
+ *
+ * Only the user's position data is returned; pool parameters such as the liquidation threshold stay with the callers
+ * that need them. iREET is the only collateral read (NFT positions are out of scope).
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param prices - USD per whole token, keyed by lowercase symbol. iREET, pmUSD, RpmUSD, DEpmUSD and RAAC are needed,
+ *   plus every coin of a Curve pool the user holds.
+ * @param provider - Optional ethers.js Provider instance. Read-only is enough.
+ * @returns Each part as `{ data, error }`, the effective return legs, and the computed effective return.
+ */
+const getUserPortfolio = async (chainId, user, prices, provider) => {
+    if (!ethers_1.ethers.isAddress(user)) {
+        throw new Error(`Invalid user address: ${user}`);
+    }
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const [collateral, debt, rates, wallet, farming, governance] = await Promise.all([
+        (0, _helpers_1.settled)((0, getUserCollateral_1.getUserCollateral)(chainId, user, provider).then((amount) => ({ amount, valueUsd: (0, _helpers_1.requireUsd)(prices, amount, "rwaindextoken") }))),
+        (0, _helpers_1.settled)((0, getUserDebt_1.getUserDebt)(chainId, user, provider).then((debt) => ({ ...debt, valueUsd: (0, _helpers_1.requireUsd)(prices, debt.amount, chains_1.default[chainId].pools.lendingpool.asset ?? "debt") }))),
+        (0, _helpers_1.settled)((0, getLendingPoolInfo_1.default)(chainId, undefined, provider).then(({ borrowRate, borrowApy, supplyApy }) => ({ borrowRate, borrowApy, supplyApy }))),
+        (0, _helpers_1.settled)((0, getUserWalletBalances_1.getUserWalletBalances)(chainId, user, provider).then((balances) => ({
+            ...balances,
+            suppliedUsd: (0, _helpers_1.requireUsd)(prices, balances.rtoken, "rtoken") + (0, _helpers_1.requireUsd)(prices, balances.detoken, "detoken"),
+            idleUsd: (0, _helpers_1.requireUsd)(prices, balances.pmusd, "pmusd"),
+        }))),
+        (0, _helpers_1.settled)((0, getUserFarming_1.getUserFarming)(chainId, user, prices, provider)),
+        (0, _helpers_1.settled)((0, getUserGovernance_1.getUserGovernance)(chainId, user, provider)),
+    ]);
+    const netPositionError = unavailable("Net RAACLend position", [collateral, debt, wallet]);
+    const netPositionUsd = netPositionError
+        ? { data: null, error: netPositionError }
+        : { data: collateral.data.valueUsd + wallet.data.suppliedUsd - debt.data.valueUsd, error: null };
+    // A pool that failed may hold part of the user's capital, so the return cannot be computed without it.
+    const farmingErrors = (farming.data?.errors ?? []).map(({ pool, error }) => ({ data: null, error: new Error(`Curve pool ${pool}: ${error.message}`) }));
+    let legs = [];
+    let effectiveReturn;
+    const returnError = unavailable("Effective return", [collateral, debt, rates, wallet, farming, ...farmingErrors]);
+    if (returnError) {
+        effectiveReturn = { data: null, error: returnError };
+    }
+    else {
+        const built = buildLegs(debt.data, rates.data, wallet.data, farming.data);
+        legs = built.legs;
+        effectiveReturn = { data: (0, computeEffectiveReturn_1.computeEffectiveReturn)({ legs, collateralUsd: collateral.data.valueUsd, idleUsd: built.idleUsd }), error: null };
+    }
+    return {
+        chainId,
+        user: ethers_1.ethers.getAddress(user),
+        collateral,
+        debt,
+        rates,
+        wallet,
+        farming,
+        governance,
+        netPositionUsd,
+        legs,
+        effectiveReturn,
+    };
+};
+exports.getUserPortfolio = getUserPortfolio;

package/dist/user/getUserWalletBalances.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserWalletBalances = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const getBalance_1 = __importDefault(require("../wallet/assets/getBalance"));
+/**
+ * The lending tokens a user holds in their wallet: RpmUSD, DEpmUSD and idle pmUSD.
+ *
+ * @param chainId - The chain/network to use.
+ * @param user - The user's address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Each balance, with its registry decimals and symbol.
+ */
+const getUserWalletBalances = async (chainId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const [rtoken, detoken, pmusd] = await Promise.all([
+        (0, getBalance_1.default)(chainId, "rtoken", user, provider),
+        (0, getBalance_1.default)(chainId, "detoken", user, provider),
+        (0, getBalance_1.default)(chainId, "pmusd", user, provider),
+    ]);
+    return { rtoken, detoken, pmusd };
+};
+exports.getUserWalletBalances = getUserWalletBalances;

package/dist/user/index.js

@@ -0,0 +1,24 @@
+"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("./computeEffectiveReturn"), exports);
+__exportStar(require("./getUserClaimables"), exports);
+__exportStar(require("./getUserCollateral"), exports);
+__exportStar(require("./getUserDebt"), exports);
+__exportStar(require("./getUserFarming"), exports);
+__exportStar(require("./getUserGovernance"), exports);
+__exportStar(require("./getUserPortfolio"), exports);
+__exportStar(require("./getUserWalletBalances"), exports);

package/dist/utils/amount.js

@@ -5,6 +5,7 @@ exports.toAmount = toAmount;
 exports.toScaled = toScaled;
 exports.parseAmount = parseAmount;
 exports.toDecimalString = toDecimalString;
+exports.toNumber = toNumber;
 exports.serializeAmount = serializeAmount;
 exports.deserializeAmount = deserializeAmount;
 exports.getAssetDecimals = getAssetDecimals;
@@ -65,6 +66,15 @@ function parseAmount(text, decimals) {
 function toDecimalString(amount) {
     return ethers_1.ethers.formatUnits(amount.value, amount.decimals);
 }
+/**
+ * An amount or scaled value as a JavaScript number, for USD and rate maths. Lossy past about 15 significant digits,
+ * so keep on-chain values as `bigint` and use this only for computed figures.
+ * @param amount The amount or scaled value, e.g. a ray rate of 3.5e25 becomes 0.035.
+ * @returns The value in whole units.
+ */
+function toNumber(amount) {
+    return Number(toDecimalString(amount));
+}
 /**
  * Converts an amount to a JSON-safe form, since `bigint` does not survive `JSON.stringify`.
  * @param amount The amount.

package/dist/utils/contracts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractAddress = exports.getContract = exports.getConfig = exports.setOverrideConfig = exports.getConfigs = void 0;
+exports.isDeployed = exports.getContractAddress = exports.getContract = exports.getConfig = exports.setOverrideConfig = exports.getConfigs = void 0;
 const configs_1 = require("../configs");
 const chains_1 = require("../configs/chains");
 const artifacts_1 = require("./artifacts");
@@ -56,7 +56,7 @@ const getContractAddress = (chainId, contractName) => {
     if (!config) {
         throw new Error(`Unsupported chain ID: ${chainId}`);
     }
-    const chainKeys = ["contracts", "governance", "assets", "pools", "nfts", "lockers", "zap", "psm"];
+    const chainKeys = ["contracts", "governance", "assets", "pools", "nfts", "lockers", "zap", "psm", "curve"];
     const keys = Object.keys(config).filter((key) => chainKeys.includes(key));
     let address = null;
     for (const key of keys) {
@@ -84,3 +84,6 @@ exports.default = {
     getConfig: exports.getConfig,
     getConfigs: exports.getConfigs,
 };
+/** Whether a config address is set and deployed: a valid, non-zero address. */
+const isDeployed = (address) => !!address && ethers_1.ethers.isAddress(address) && address !== ethers_1.ethers.ZeroAddress;
+exports.isDeployed = isDeployed;

package/package.json

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