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

package/dist/RPCLibrary.js

@@ -204,6 +204,10 @@ const distributorMethods = __importStar(require("./contracts/governance/distribu
 const gaugeMethods = __importStar(require("./contracts/governance/gauge"));
 const controllerMethods = __importStar(require("./contracts/governance/gaugeController"));
 const gaugeSystemMethods = __importStar(require("./contracts/governance/gaugeSystems"));
+// ===== Curve =====
+const curveCommonMethods = __importStar(require("./contracts/curve/common"));
+// ===== User aggregates (dashboard) =====
+const userMethods = __importStar(require("./user"));
 // Proposals
 const cancel_1 = require("./contracts/governance/proposals/cancel");
 const getQuorumNumerator_1 = require("./contracts/governance/proposals/getQuorumNumerator");
@@ -400,6 +404,10 @@ class RPCLibrary {
     chainId;
     privateKey;
     // prices
+    // Curve pools from the chain config's `curve` section
+    curve;
+    // Aggregate reads of one user's position and claimables, composed from the methods above
+    user;
     prices;
     // valid
     assets;
@@ -846,6 +854,10 @@ class RPCLibrary {
             priceAt: priceAt_1.priceAt,
             quoteBuy: quoteBuy_1.quoteBuy,
         };
+        this.curve = {
+            common: curveCommonMethods,
+        };
+        this.user = userMethods;
         this.prices = {
             getPrices: getPrices_1.getPrices,
             getTokenPriceUSD: tokenPricesUSD_1.getTokenPriceUSD,
@@ -859,6 +871,7 @@ class RPCLibrary {
             toScaled: amount_1.toScaled,
             parseAmount: amount_1.parseAmount,
             toDecimalString: amount_1.toDecimalString,
+            toNumber: amount_1.toNumber,
             serializeAmount: amount_1.serializeAmount,
             deserializeAmount: amount_1.deserializeAmount,
             getAssetDecimals: amount_1.getAssetDecimals,

package/dist/configs/chains/11155111.json

@@ -179,6 +179,36 @@
             "contract": "0x7F7d0924C9082F4C3F0D5D97bF9a26C3D3DEf706"
         }
     },
+    "curve": {
+        "raac-pmusd": {
+            "id": "raac-pmusd",
+            "name": "RAAC / pmUSD",
+            "contract": "0xF65C691aE1782A9A504d6865F0dAeC88Ef46a592",
+            "flavour": "twocrypto",
+            "coins": ["pmusd", "raactoken"]
+        },
+        "ireet-pmusd": {
+            "id": "ireet-pmusd",
+            "name": "iREET / pmUSD",
+            "contract": "0x7F7d0924C9082F4C3F0D5D97bF9a26C3D3DEf706",
+            "flavour": "twocrypto",
+            "coins": ["pmusd", "rwaindextoken"]
+        },
+        "rpmusd-depmusd": {
+            "id": "rpmusd-depmusd",
+            "name": "RpmUSD / DEpmUSD",
+            "contract": "0x421E9431E751c8fC02E53F8e54a1772aE6021BeD",
+            "flavour": "stableswap",
+            "coins": ["rtoken", "detoken"]
+        },
+        "leraac-raac-pmusd": {
+            "id": "leraac-raac-pmusd",
+            "name": "leRAAC / RAAC / pmUSD",
+            "contract": "0x1D0805Bd3EF5338b66158770c28fD6f4Cd685F28",
+            "flavour": "tricrypto",
+            "coins": ["pmusd", "raactoken", "leraac"]
+        }
+    },
     "nfts": {
         "raacnft": {
             "id": "raacnft",

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurvePools = exports.CURVE_POOL_READ_ABI = void 0;
+exports.resolveCurvePool = resolveCurvePool;
+exports.getCurvePoolContract = getCurvePoolContract;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+/**
+ * Reads every Curve pool flavour shares. Coin indexes differ (uint256 vs int128) only in swap and liquidity
+ * methods, which are not here.
+ */
+exports.CURVE_POOL_READ_ABI = [
+    "function coins(uint256) view returns (address)",
+    "function balances(uint256) view returns (uint256)",
+    "function totalSupply() view returns (uint256)",
+    "function balanceOf(address) view returns (uint256)",
+    "function get_virtual_price() view returns (uint256)",
+];
+const getCurvePools = (chainId) => chains_1.default[chainId]?.curve ?? {};
+exports.getCurvePools = getCurvePools;
+/** Resolves a Curve pool by its config key (any casing) or its address. */
+function resolveCurvePool(chainId, poolAddressOrId) {
+    const pools = (0, exports.getCurvePools)(chainId);
+    const needle = poolAddressOrId.toLowerCase();
+    const entry = pools[needle] ?? Object.values(pools).find((pool) => pool.contract.toLowerCase() === needle);
+    if (!entry)
+        throw new Error(`Curve pool "${poolAddressOrId}" not configured for chain ${chainId}`);
+    return entry;
+}
+function getCurvePoolContract(chainId, poolAddressOrId, provider) {
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    }
+    const entry = resolveCurvePool(chainId, poolAddressOrId);
+    return { entry, contract: new ethers_1.ethers.Contract(entry.contract, exports.CURVE_POOL_READ_ABI, provider), provider };
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPool = exports.getPools = void 0;
+const amount_1 = require("../../../utils/amount");
+const contracts_1 = require("../../../utils/contracts");
+const _helpers_1 = require("./_helpers");
+const toPool = (chainId, entry) => ({
+    ...entry,
+    coins: entry.coins.map((asset) => {
+        const info = (0, amount_1.getTokenInfo)(chainId, asset);
+        return {
+            asset,
+            address: (0, contracts_1.getContractAddress)(chainId, asset),
+            symbol: info?.symbol ?? asset,
+            decimals: info?.decimals ?? 18,
+        };
+    }),
+});
+/**
+ * Lists the Curve pools in the chain config.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured pool with its flavour and coins in pool index order; empty when the chain has none.
+ */
+const getPools = (chainId) => Object.values((0, _helpers_1.getCurvePools)(chainId)).map((entry) => toPool(chainId, entry));
+exports.getPools = getPools;
+/**
+ * Looks up one Curve pool in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's config key or its address.
+ * @returns The pool with its flavour and coins in pool index order.
+ * @throws If the pool is not configured on the chain.
+ */
+const getPool = (chainId, poolAddressOrId) => toPool(chainId, (0, _helpers_1.resolveCurvePool)(chainId, poolAddressOrId));
+exports.getPool = getPool;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualPrice = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Reads a Curve pool's virtual price: the value of one whole LP token in units of the pool's underlying coins,
+ * which only grows with fees. For a stableswap pool of $1 coins it is the LP token's USD price.
+ *
+ * @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 `get_virtual_price()` as an 18-decimal amount, e.g. 1.0021 underlying per LP token.
+ */
+const getVirtualPrice = async (chainId, poolAddressOrId, provider) => {
+    const { entry, contract } = (0, _helpers_1.getCurvePoolContract)(chainId, poolAddressOrId, provider);
+    try {
+        const price = await contract.get_virtual_price();
+        return (0, amount_1.toAmount)(price, amount_1.WAD_DECIMALS);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("curve.common.getVirtualPrice", error, { chainId, address: entry.contract });
+    }
+};
+exports.getVirtualPrice = getVirtualPrice;

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

@@ -0,0 +1,18 @@
+"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("./getPools"), exports);
+__exportStar(require("./getVirtualPrice"), exports);

package/dist/contracts/findContract.js

@@ -7,10 +7,10 @@ exports.findContract = void 0;
 const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../configs/chains"));
 const artifacts_1 = require("../utils/artifacts");
+const contracts_1 = require("../utils/contracts");
 /** Sections scanned in order; the first match wins. */
-const FLAT_SECTIONS = ["contracts", "governance", "pools", "lockers", "zap", "psm", "nfts", "assets"];
+const FLAT_SECTIONS = ["contracts", "governance", "pools", "lockers", "zap", "psm", "nfts", "assets", "curve"];
 const abiKey = (key) => (key in artifacts_1.ABIS ? key : null);
-const isDeployed = (address) => !!address && ethers_1.ethers.isAddress(address) && address !== ethers_1.ethers.ZeroAddress;
 /** Builds every configured contract on the chain with its name and ABI key. */
 function listContracts(chainId) {
     const config = chains_1.default[chainId];
@@ -19,7 +19,7 @@ function listContracts(chainId) {
     }
     const found = [];
     const push = (entry) => {
-        if (isDeployed(entry.address))
+        if ((0, contracts_1.isDeployed)(entry.address))
             found.push({ ...entry, address: ethers_1.ethers.getAddress(entry.address) });
     };
     // gauges: { <system>: { label, gaugeType, controller, distributor, gauges: [{ id, name, contract }] } }

package/dist/contracts/getContractAddress.js

@@ -31,6 +31,7 @@ const getContractAddress = (chainId, contractName) => {
         "lockers",
         "zap",
         "psm",
+        "curve",
     ];
     let address = null;
     for (const key of lookupKeys) {

package/dist/contracts/governance/gaugeSystems/_helpers.js

@@ -7,8 +7,8 @@ exports.resolveGauge = exports.lookupGauge = exports.listGauges = exports.resolv
 const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../../../configs/chains"));
 const _helpers_1 = require("../_helpers");
+const contracts_1 = require("../../../utils/contracts");
 exports.GAUGE_SYSTEM_IDS = ["raacgauges", "rwagauges"];
-const isDeployed = (address) => !!address && ethers_1.ethers.isAddress(address) && address !== ethers_1.ethers.ZeroAddress;
 /**
  * Reads the `gauges` section of a chain config.
  *
@@ -51,7 +51,7 @@ const resolveSystemContract = (chainId, ref, field, name) => {
         return (0, _helpers_1.requireAddress)(ref, name);
     }
     const system = (0, exports.requireGaugeSystem)(chainId, ref);
-    if (!isDeployed(system[field])) {
+    if (!(0, contracts_1.isDeployed)(system[field])) {
         throw new Error(`Gauge system "${system.id}" has no ${name} deployed on chainId: ${chainId}`);
     }
     return ethers_1.ethers.getAddress(system[field]);

package/dist/pools/lendingPool/adapters/erc20/getERC20AdapterBalance.js

@@ -9,16 +9,16 @@ const rpcError_1 = require("../../../../utils/rpcError");
  * @param chainId The chain id, used to look up the adapter token's decimals in the token registry.
  * @param adapterAddress The ERC20 asset adapter address.
  * @param userAddress The user.
- * @param signer The signer to read with.
+ * @param runner The signer or provider to read with. A read-only provider is enough.
  * @returns The deposited balance in base units of the adapter's token, with its registry decimals and symbol (18 decimals if the token is not in the registry).
  */
-async function getERC20AdapterBalance(chainId, adapterAddress, userAddress, signer) {
-    if (!signer) {
+async function getERC20AdapterBalance(chainId, adapterAddress, userAddress, runner) {
+    if (!runner) {
         throw new Error("Wallet not connected");
     }
     try {
         const abi = (0, artifacts_1.getABI)("erc20assetadapter");
-        const adapterContract = new ethers_1.ethers.Contract(adapterAddress, abi, signer);
+        const adapterContract = new ethers_1.ethers.Contract(adapterAddress, abi, runner);
         const [balance, token] = await Promise.all([
             adapterContract.balanceOf(userAddress),
             adapterContract.token(),

package/dist/types/RPCLibrary.d.ts

@@ -134,11 +134,13 @@ import { cancelExit as cancelExitPsm } from "./contracts/psm/cancelExit";
 import { redeem as redeemPsm } from "./contracts/psm/redeem";
 import { swap as swapPsm } from "./contracts/psm/swap";
 import { getABI } from "./utils/artifacts";
-import { toAmount, toScaled, parseAmount, toDecimalString, serializeAmount, deserializeAmount, getAssetDecimals, getTokenInfo, toTokenAmount } from "./utils/amount";
+import { toAmount, toScaled, parseAmount, toDecimalString, toNumber, serializeAmount, deserializeAmount, getAssetDecimals, getTokenInfo, toTokenAmount } from "./utils/amount";
 import * as distributorMethods from "./contracts/governance/distributor";
 import * as gaugeMethods from "./contracts/governance/gauge";
 import * as controllerMethods from "./contracts/governance/gaugeController";
 import * as gaugeSystemMethods from "./contracts/governance/gaugeSystems";
+import * as curveCommonMethods from "./contracts/curve/common";
+import * as userMethods from "./user";
 import { cancel as cancelProposals } from "./contracts/governance/proposals/cancel";
 import { getQuorumNumerator as getQuorumNumeratorProposals } from "./contracts/governance/proposals/getQuorumNumerator";
 import { getVotingPeriod as getVotingPeriodProposals } from "./contracts/governance/proposals/getVotingPeriod";
@@ -316,6 +318,10 @@ declare class RPCLibrary {
     address: JsonRpcSigner | string;
     chainId: ChainId | bigint | null;
     privateKey: any;
+    curve: {
+        common: typeof curveCommonMethods;
+    };
+    user: typeof userMethods;
     prices: {
         getPrices: typeof getPrices;
         getTokenPriceUSD: typeof getTokenPriceUSD;
@@ -732,6 +738,7 @@ declare class RPCLibrary {
         toScaled: typeof toScaled;
         parseAmount: typeof parseAmount;
         toDecimalString: typeof toDecimalString;
+        toNumber: typeof toNumber;
         serializeAmount: typeof serializeAmount;
         deserializeAmount: typeof deserializeAmount;
         getAssetDecimals: typeof getAssetDecimals;

package/dist/types/contracts/curve/common/_helpers.d.ts

@@ -0,0 +1,16 @@
+import { ethers, Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry, CurvePools } from "../../../configs/chains/chain";
+/**
+ * Reads every Curve pool flavour shares. Coin indexes differ (uint256 vs int128) only in swap and liquidity
+ * methods, which are not here.
+ */
+export declare const CURVE_POOL_READ_ABI: string[];
+export declare const getCurvePools: (chainId: ChainId) => CurvePools;
+/** Resolves a Curve pool by its config key (any casing) or its address. */
+export declare function resolveCurvePool(chainId: ChainId, poolAddressOrId: string): CurvePoolEntry;
+export declare function getCurvePoolContract(chainId: ChainId, poolAddressOrId: string, provider?: Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+    provider: ethers.Provider;
+};

package/dist/types/contracts/curve/common/getPools.d.ts

@@ -0,0 +1,30 @@
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry } from "../../../configs/chains/chain";
+export interface CurvePoolCoin {
+    /** Asset key in the chain config, e.g. "pmusd". */
+    asset: string;
+    address: string;
+    /** From the token registry; the asset key when the registry has no symbol. */
+    symbol: string;
+    decimals: number;
+}
+export interface CurvePool extends Omit<CurvePoolEntry, "coins"> {
+    /** In pool index order: coins[i] is coin i on chain. */
+    coins: CurvePoolCoin[];
+}
+/**
+ * Lists the Curve pools in the chain config.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured pool with its flavour and coins in pool index order; empty when the chain has none.
+ */
+export declare const getPools: (chainId: ChainId) => CurvePool[];
+/**
+ * Looks up one Curve pool in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's config key or its address.
+ * @returns The pool with its flavour and coins in pool index order.
+ * @throws If the pool is not configured on the chain.
+ */
+export declare const getPool: (chainId: ChainId, poolAddressOrId: string) => CurvePool;

package/dist/types/contracts/curve/common/getVirtualPrice.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Reads a Curve pool's virtual price: the value of one whole LP token in units of the pool's underlying coins,
+ * which only grows with fees. For a stableswap pool of $1 coins it is the LP token's USD price.
+ *
+ * @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 `get_virtual_price()` as an 18-decimal amount, e.g. 1.0021 underlying per LP token.
+ */
+export declare const getVirtualPrice: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/curve/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./getPools";
+export * from "./getVirtualPrice";

package/dist/types/pools/lendingPool/adapters/erc20/getERC20AdapterBalance.d.ts

@@ -1,4 +1,4 @@
-import { Signer } from "ethers";
+import { Provider, Signer } from "ethers";
 import { ChainId } from "../../../../configs/chains";
 import { TokenAmount } from "../../../../utils/amount";
 /**
@@ -6,8 +6,8 @@ import { TokenAmount } from "../../../../utils/amount";
  * @param chainId The chain id, used to look up the adapter token's decimals in the token registry.
  * @param adapterAddress The ERC20 asset adapter address.
  * @param userAddress The user.
- * @param signer The signer to read with.
+ * @param runner The signer or provider to read with. A read-only provider is enough.
  * @returns The deposited balance in base units of the adapter's token, with its registry decimals and symbol (18 decimals if the token is not in the registry).
  */
-declare function getERC20AdapterBalance(chainId: ChainId, adapterAddress: string, userAddress: string, signer: Signer): Promise<TokenAmount>;
+declare function getERC20AdapterBalance(chainId: ChainId, adapterAddress: string, userAddress: string, runner: Signer | Provider): Promise<TokenAmount>;
 export default getERC20AdapterBalance;

package/dist/types/user/_helpers.d.ts

@@ -0,0 +1,23 @@
+import { TokenAmount } from "../utils/amount";
+/**
+ * USD price of one whole token, keyed by lowercase symbol, e.g. `{ raac: 5, pmusd: 1, ireet: 0.995 }`. The app
+ * builds it with its `usePrices` hook, so the rpc and the UI value everything identically.
+ */
+export type UsdPrices = Record<string, number>;
+/** A read that settled independently of the others: its data, or why it failed. One failure never blanks the rest. */
+export type Section<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: Error;
+};
+/** Settles one read into a {@link Section}: never rejects, so reads awaited together fail independently. */
+export declare const settled: <T>(read: Promise<T>) => Promise<Section<T>>;
+/**
+ * USD value of an amount from `prices`, by the symbol `toTokenAmount` gave it from the chain config's token registry.
+ * Throws when there is no price, so the section fails visibly instead of reading 0.
+ *
+ * @param token - The amount's asset key or token address, named in the error.
+ */
+export declare function requireUsd(prices: UsdPrices, amount: TokenAmount, token: string): number;

package/dist/types/user/computeEffectiveReturn.d.ts

@@ -0,0 +1,67 @@
+/** Whether a leg earns income or costs it. */
+export type ReturnLegKind = "earning" | "cost";
+/** What a leg earns or costs. A unit of capital earns each yield type at most once. */
+export type ReturnLegYieldType = "supply" | "gauge" | "borrow";
+/**
+ * One income stream in the user's position, as {@link computeEffectiveReturn} consumes it. Adding a venue (a new
+ * gauge, another pmUSD venue) only means adding a leg; the calculator does not change.
+ */
+export interface ReturnLeg {
+    /** Stable key, e.g. "borrow", "supply", "gauge:r-rpmdepmUSD". */
+    id: string;
+    /** Display name, e.g. "Borrow pmUSD". */
+    source: string;
+    kind: ReturnLegKind;
+    yieldType: ReturnLegYieldType;
+    /**
+     * True when the leg's value is money the user holds and counts towards net capital (supplied). False for the
+     * debt itself, and for overlays such as a gauge, whose staked value is already counted in another leg.
+     */
+    countsAsCapital: boolean;
+    /** USD value the rate applies to. Never negative. */
+    valueUsd: number;
+    /** The projected one-year rate as a fraction, e.g. 0.0077 for 0.77%. */
+    rate: number;
+    /** How `rate` is quoted: "apy" when it already compounds (borrow), "apr" when it does not (supply, gauge). */
+    rateKind: "apr" | "apy";
+}
+export interface ReturnLegWithIncome extends ReturnLeg {
+    /** Projected income over one year in USD: `valueUsd * rate`, negative for a cost leg. */
+    income1y: number;
+}
+export interface EffectiveReturnInput {
+    legs: readonly ReturnLeg[];
+    /** USD value of the collateral backing the debt. */
+    collateralUsd: number;
+    /**
+     * USD value of capital that earns nothing, e.g. idle pmUSD in the wallet or a non-yielding coin inside a staked
+     * LP. It is not a leg (no income, not listed in a breakdown); it only adds to net capital.
+     */
+    idleUsd?: number;
+}
+export interface EffectiveReturn {
+    /** Earning legs' income minus cost legs' cost over one year, in USD. */
+    netIncome1y: number;
+    /** `netIncome1y / debtUsd` as a fraction; null when there is no debt. */
+    onDebt: number | null;
+    /** `netIncome1y / netCapitalUsd` as a fraction; null when net capital is zero or negative. */
+    onNetCapital: number | null;
+    /** Sum of the cost legs' values. */
+    debtUsd: number;
+    /** Collateral + capital legs + idle - debt. */
+    netCapitalUsd: number;
+    legs: ReturnLegWithIncome[];
+}
+/**
+ * Projects the user's net return over one year from a list of legs. Pure: no reads.
+ *
+ *   netIncome1y  = sum(earning valueUsd * rate) - sum(cost valueUsd * rate)
+ *   onDebt       = netIncome1y / total debt
+ *   onNetCapital = netIncome1y / (collateral + capital legs + idle - total debt)
+ *
+ * The legs do not reinvest into each other, so this is a projected net return, not an APY.
+ *
+ * @param input - The legs, the collateral value and any idle capital, all in USD.
+ * @returns The net income, both returns and each leg with its own projected income.
+ */
+export declare function computeEffectiveReturn({ legs, collateralUsd, idleUsd }: EffectiveReturnInput): EffectiveReturn;

package/dist/types/user/getUserClaimables.d.ts

@@ -0,0 +1,55 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { GaugeSystemId } from "../configs/chains/chain";
+import { TokenAmount } from "../utils/amount";
+export interface ClaimableToken {
+    /** Token address. */
+    token: string;
+    amount: TokenAmount;
+}
+export interface ClaimableSource {
+    /** False when the source is not deployed on this chain. Nothing to show. */
+    available: boolean;
+    /** Tokens with a non-zero claimable amount. */
+    tokens: ClaimableToken[];
+    /** Why the source could not be read. The UI shows it on this row, never a silent zero. */
+    error: Error | null;
+}
+export interface GaugeClaimable extends ClaimableSource {
+    gauge: string;
+    id: string;
+    name: string;
+    system: GaugeSystemId;
+}
+export interface GaugeClaimables extends ClaimableSource {
+    /** One entry per configured gauge, including those with nothing to claim or a failed read. */
+    items: GaugeClaimable[];
+    /** Number of gauges with something to claim. */
+    claimableCount: number;
+}
+export interface UserClaimables {
+    chainId: ChainId;
+    user: string;
+    /** Main and extra rewards on every configured gauge of both systems. Claimed gauge RAAC goes to the liquid locker. */
+    gauges: GaugeClaimables;
+    /** veRAAC fee distributions, one token per reward token. */
+    veRAAC: ClaimableSource;
+    /** Realised RAAC in the maturity vault. */
+    maturityVault: ClaimableSource;
+    /** Bot locker rewards, every reward token. */
+    botLocker: ClaimableSource;
+}
+/**
+ * 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.
+ */
+export declare const getUserClaimables: (chainId: ChainId, user: string, provider?: Provider) => Promise<UserClaimables>;

package/dist/types/user/getUserCollateral.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { TokenAmount } from "../utils/amount";
+/**
+ * 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.
+ */
+export declare const getUserCollateral: (chainId: ChainId, user: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/user/getUserDebt.d.ts

@@ -0,0 +1,18 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { ScaledValue, TokenAmount } from "../utils/amount";
+export interface UserDebt {
+    /** Current debt including accrued interest, in reserve units (pmUSD). */
+    amount: TokenAmount;
+    /** WAD health factor (liquidatable below 1e18); null when there is no debt. */
+    healthFactor: ScaledValue | null;
+}
+/**
+ * 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.
+ */
+export declare const getUserDebt: (chainId: ChainId, user: string, provider?: Provider) => Promise<UserDebt>;

package/dist/types/user/getUserFarming.d.ts

@@ -0,0 +1,64 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { TokenAmount } from "../utils/amount";
+import { UsdPrices } from "./_helpers";
+/** What a coin earns on its own while it sits in a pool. */
+export type UnderlyingYield = 
+/** Earns the lending pool supply rate (RpmUSD, DEpmUSD), wherever it sits. */
+"supply"
+/** Earns nothing on its own (pmUSD, RAAC; iREET for now, with fixed pricing). Counts only as capital. */
+ | "none";
+export interface FarmingPoolCoin {
+    asset: string;
+    /** The user's share of the pool's balance of this coin, through LP in the wallet and staked in gauges. */
+    amount: TokenAmount;
+    valueUsd: number;
+    yield: UnderlyingYield;
+}
+export interface FarmingPool {
+    /** Curve pool id in the chain config. */
+    pool: string;
+    address: string;
+    /** LP held in the wallet. */
+    walletLp: TokenAmount;
+    /** LP staked in the pool's gauges. */
+    stakedLp: TokenAmount;
+    /** The user's share of each coin; empty when the user holds none of the pool's LP. */
+    coins: FarmingPoolCoin[];
+}
+export interface FarmingGauge {
+    /** Gauge id in the chain config. */
+    id: string;
+    gauge: string;
+    name: string;
+    pool: string;
+    /** LP staked (raw balance, not boosted). */
+    staked: TokenAmount;
+    /** Staked LP valued through the pool's coins at the passed prices. */
+    valueUsd: number;
+    /** The user's current boosted reward APR as a fraction; null with no stake. */
+    apr: number | null;
+}
+export interface UserFarming {
+    pools: FarmingPool[];
+    /** Every gauge on a read pool, including those the user has no stake in. */
+    gauges: FarmingGauge[];
+    /** Pools that could not be read. They and their gauges are left out of `pools` and `gauges`. */
+    errors: {
+        pool: string;
+        error: Error;
+    }[];
+}
+/**
+ * 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.
+ */
+export declare const getUserFarming: (chainId: ChainId, user: string, prices: UsdPrices, provider?: Provider) => Promise<UserFarming>;