@raac/rpc 2.0.0-beta.6 → 2.0.0-beta.8

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/artifacts.js

@@ -38,6 +38,8 @@ const RWAIndexTokenCollector_json_1 = __importDefault(require("../artifacts/core
 const RAACTokenCollector_json_1 = __importDefault(require("../artifacts/core/collectors/RAACTokenCollector.sol/RAACTokenCollector.json"));
 const CrvUSDToUSDOracle_json_1 = __importDefault(require("../artifacts/core/oracles/CrvUSDToUSDOracle.sol/CrvUSDToUSDOracle.json"));
 const NFTRoyaltyFeeCollector_json_1 = __importDefault(require("../artifacts/core/collectors/NFTRoyaltyFeeCollector.sol/NFTRoyaltyFeeCollector.json"));
+const RentStreamer_json_1 = __importDefault(require("../artifacts/core/collectors/fee-streamer/RentStreamer.sol/RentStreamer.json"));
+const USDCTokenLimited_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/USDCTokenLimited.sol/USDCTokenLimited.json"));
 const GaugeController_json_1 = __importDefault(require("../artifacts/core/governance/gauges/GaugeController.sol/GaugeController.json"));
 const BaseGauge_json_1 = __importDefault(require("../artifacts/core/governance/gauges/BaseGauge.sol/BaseGauge.json"));
 const RAACGauge_json_1 = __importDefault(require("../artifacts/core/governance/gauges/RAACGauge.sol/RAACGauge.json"));
@@ -93,6 +95,7 @@ const ABIS = {
     // Tokens
     crvusd: CRVUSD_ABI,
     pmusd: PMUSD_ABI,
+    usdc: USDCTokenLimited_json_1.default.abi,
     xpm: XPM_ABI,
     // RAAC
     raacnft: RAACNFT_ABI,
@@ -134,6 +137,7 @@ const ABIS = {
     raactokencollector: RAACTokenCollector_json_1.default.abi,
     crvusdtousdoracle: CRVUSDTOUSDORACLE_ABI,
     nftroyaltyfeecollector: NFTRoyaltyFeeCollector_json_1.default.abi,
+    rentstreamer: RentStreamer_json_1.default.abi,
     // Governance
     gaugecontroller: GAUGECONTROLLER_ABI,
     basegauge: BASEGAUGE_ABI,

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.6",
+	"version": "2.0.0-beta.8",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",