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

package/dist/pools/stabilityPool/getWithdrawRequestInfo.js

@@ -4,6 +4,8 @@ exports.getWithdrawRequestInfo = getWithdrawRequestInfo;
 const _helpers_1 = require("./_helpers");
 const _helpers_2 = require("../lendingPool/_helpers");
 const amount_1 = require("../../utils/amount");
+const getContractAddress_1 = require("../../contracts/getContractAddress");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads a user's pending stability pool withdraw request.
  * @param chainId The chain id.
@@ -12,6 +14,7 @@ const amount_1 = require("../../utils/amount");
  * @returns The request, or `null` when there is none.
  */
 async function getWithdrawRequestInfo(chainId, userAddress, provider) {
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "stabilitypool");
     try {
         const stabilityPoolContract = await (0, _helpers_1.getStabilityPoolContract)(chainId, provider);
         const [duration, request] = await Promise.all([
@@ -32,7 +35,6 @@ async function getWithdrawRequestInfo(chainId, userAddress, provider) {
         };
     }
     catch (error) {
-        console.error("Error in getWithdrawRequestInfo:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("stabilityPool.getWithdrawRequestInfo", error, { chainId, address: contractAddress });
     }
 }

package/dist/pools/stabilityPool/getWithdrawTimelockConfig.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWithdrawTimelockConfig = getWithdrawTimelockConfig;
+const _helpers_1 = require("./_helpers");
+const getContractAddress_1 = require("../../contracts/getContractAddress");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Reads the stability pool's withdraw timelock configuration. The pool's
+ * actual enforced window for a given request is `readyAt + delay` (see
+ * `getWithdrawRequestInfo`'s `readyAt`), not `withdrawTimelock(user).expireAt`.
+ */
+async function getWithdrawTimelockConfig(chainId, provider) {
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "stabilitypool");
+    try {
+        const stabilityPoolContract = await (0, _helpers_1.getStabilityPoolContract)(chainId, provider);
+        const [duration, delay] = await Promise.all([
+            stabilityPoolContract.withdrawTimelockDuration(),
+            stabilityPoolContract.withdrawTimelockDelay(),
+        ]);
+        return { duration: Number(duration), delay: Number(delay) };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("stabilityPool.getWithdrawTimelockConfig", error, { chainId, address: contractAddress });
+    }
+}

package/dist/pools/stabilityPool/liquidation.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minSharesOut = exports.sameSplit = exports.splitTotal = exports.SPLIT_KEYS = void 0;
+exports.readLiquidationContext = readLiquidationContext;
+exports.readLiquidationTarget = readLiquidationTarget;
+exports.quoteLiquidation = quoteLiquidation;
+exports.suggestSplit = suggestSplit;
+exports.simulateWithSplit = simulateWithSplit;
+/**
+ * Liquidation simulation for StabilityPool.liquidateBorrower, mirroring LiquidationStrategyProxy:
+ *   1. the seized collateral is deposited into the RWAVault for vault-token shares, unless it already is the vault token;
+ *   2. the stability pool's whole vault-token balance (the proxy runs under delegatecall) is split by BPS into
+ *      mint (treasury fee), burn, swap and liquidity (fee collector);
+ *   3. only the swap slice becomes crvUSD, through LiquidationSwap and its Curve pool;
+ *   3b. LiquidationSwap reverts when slippage protection is on and get_dy falls below pricePerShare / oracle price
+ *       less its tolerance, which is the case when Curve trades below the vault's value;
+ *   4. the crvUSD must cover the position's debt; any shortfall is withdrawn from the LendingPool with the pool's
+ *      rTokens, so stability pool depositors pay it, and the call reverts (InsufficientBalance) if they hold too few.
+ */
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const getAdapters_1 = __importDefault(require("../rwaVault/getAdapters"));
+const getParameters_1 = __importDefault(require("../lendingPool/getParameters"));
+const BPS = BigInt(10_000);
+const WAD = BigInt(10) ** BigInt(18);
+const ZERO = BigInt(0);
+const SWAP_ABI = [
+    "function liquidityPool() view returns (address)",
+    "function swapToken() view returns (address)",
+    "function iIn() view returns (uint256)",
+    "function iOut() view returns (uint256)",
+    "function enableSlippageProtection() view returns (bool)",
+    "function slippageProtectionBps() view returns (uint256)",
+    "function crvusdToUSDOracle() view returns (address)",
+];
+const CURVE_ABI = ["function get_dy(uint256 i, uint256 j, uint256 dx) view returns (uint256)", "function balances(uint256 i) view returns (uint256)"];
+const VAULT_ABI = ["function underlyingVaultToken() view returns (address)", "function previewDeposit(uint256 assetAmount) view returns (uint256)", "function pricePerShare() view returns (uint256)"];
+const VAULT_ADAPTER_ABI = ["function getAssetToken() view returns (address)", "function getAssetValue(bytes data) view returns (uint256)"];
+const ADAPTER_ABI = [
+    "function getAssetToken() view returns (address)",
+    "function getAssetType() view returns (string)",
+    "function getAssetValue(address user, bytes data) view returns (uint256)",
+    "function balanceOf(address user) view returns (uint256)",
+    "function getDepositedTokens(address user) view returns (uint256[])",
+];
+const ERC20_ABI = ["function balanceOf(address) view returns (uint256)"];
+exports.SPLIT_KEYS = ["mintBps", "burnBps", "swapBps", "liquidityBps"];
+const splitTotal = (s) => s.mintBps + s.burnBps + s.swapBps + s.liquidityBps;
+exports.splitTotal = splitTotal;
+const sameSplit = (a, b) => exports.SPLIT_KEYS.every((k) => a[k] === b[k]);
+exports.sameSplit = sameSplit;
+const contract = (address, abi, provider) => new ethers_1.ethers.Contract(address, abi, provider);
+const decodeAmount = (data) => ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["uint256"], data)[0];
+/** Reads the stability pool's liquidation route, split, balances and the LendingPool grace period. */
+async function readLiquidationContext(chainId, provider) {
+    const stabilityPool = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+    const sp = contract(stabilityPool, (0, artifacts_1.getABI)("stabilitypool"), provider);
+    const [liquidationSwap, rwaVault, split, rToken, params] = await Promise.all([
+        sp.liquidationSwap(),
+        sp.rwaVault(),
+        sp.liquidationSplit(),
+        sp.rToken(),
+        (0, getParameters_1.default)(chainId, provider),
+    ]);
+    if (liquidationSwap === ethers_1.ethers.ZeroAddress)
+        throw new Error("The stability pool has no LiquidationSwap set, so the swap leg reverts.");
+    const swap = contract(liquidationSwap, SWAP_ABI, provider);
+    const vault = contract(rwaVault, VAULT_ABI, provider);
+    const [liquidityPool, iIn, iOut, vaultToken, protect] = await Promise.all([
+        swap.liquidityPool(),
+        swap.iIn(),
+        swap.iOut(),
+        vault.underlyingVaultToken(),
+        swap.enableSlippageProtection(),
+    ]);
+    const slippage = protect
+        ? await Promise.all([
+            swap.slippageProtectionBps(),
+            vault.pricePerShare(),
+            swap.crvusdToUSDOracle().then((o) => contract(o, ["function getPrice() view returns (uint256)"], provider).getPrice()),
+        ]).then(([bps, pricePerShare, oraclePrice]) => ({ bps, pricePerShare, oraclePrice }))
+        : null;
+    if (liquidityPool === ethers_1.ethers.ZeroAddress)
+        throw new Error("LiquidationSwap has no Curve pool set, so the swap leg reverts.");
+    const [vaultSymbol, poolVaultTokens, rTokens] = await Promise.all([
+        contract(vaultToken, ["function symbol() view returns (string)"], provider).symbol().catch(() => "vault token"),
+        contract(vaultToken, ERC20_ABI, provider).balanceOf(stabilityPool),
+        contract(rToken, ERC20_ABI, provider).balanceOf(stabilityPool),
+    ]);
+    return {
+        stabilityPool,
+        liquidationSwap,
+        liquidityPool,
+        rwaVault,
+        vaultToken,
+        vaultSymbol,
+        iIn,
+        iOut,
+        split: { mintBps: split[0], burnBps: split[1], swapBps: split[2], liquidityBps: split[3] },
+        poolVaultTokens,
+        rTokens,
+        gracePeriod: Number(params.liquidationGracePeriod),
+        slippage,
+    };
+}
+/**
+ * Rebuilds the `data` the pool adapter expects. Position ids are "user:adapter:key" with `key` a hash, so the
+ * adapter's deposits are enumerated and matched against it (ERC721AssetAdapter keys are
+ * keccak256(abi.encodePacked(token, tokenId))). ERC20 adapters only accept the full deposited balance.
+ */
+async function readLiquidationData(provider, poolAdapter, user, positionKey) {
+    const adapter = contract(poolAdapter, ADAPTER_ABI, provider);
+    const [assetType, assetToken] = await Promise.all([adapter.getAssetType(), adapter.getAssetToken()]);
+    const coder = ethers_1.ethers.AbiCoder.defaultAbiCoder();
+    if (assetType === "ERC721") {
+        const ids = [...(await adapter.getDepositedTokens(user))];
+        if (!ids.length)
+            throw new Error("The adapter holds no NFT collateral for this borrower anymore.");
+        const tokenId = positionKey ? ids.find((id) => ethers_1.ethers.solidityPackedKeccak256(["address", "uint256"], [assetToken, id]) === positionKey.toLowerCase()) : ids[0];
+        if (tokenId === undefined)
+            throw new Error("None of the borrower's deposited NFTs matches this position.");
+        return { data: coder.encode(["uint256"], [tokenId]), assetType, assetToken };
+    }
+    const balance = await adapter.balanceOf(user);
+    if (balance === ZERO)
+        throw new Error("The adapter holds no collateral for this borrower anymore.");
+    return { data: coder.encode(["uint256"], [balance]), assetType, assetToken };
+}
+/** The RWAVault adapter for the collateral's token; LiquidationStrategyProxy reverts (AdaptersAssetMismatch) otherwise. */
+async function findVaultAdapter(chainId, provider, assetToken, vaultToken) {
+    const { adapters } = await (0, getAdapters_1.default)(chainId, provider);
+    for (const candidate of adapters) {
+        const token = await contract(candidate, VAULT_ADAPTER_ABI, provider).getAssetToken().catch(() => null);
+        if (token?.toLowerCase() === assetToken.toLowerCase())
+            return ethers_1.ethers.getAddress(candidate);
+    }
+    // Vault-token collateral skips the deposit, so any adapter passes the proxy's check.
+    if (assetToken.toLowerCase() === vaultToken.toLowerCase() && adapters.length)
+        return ethers_1.ethers.getAddress(adapters[0]);
+    throw new Error("No RWAVault adapter accepts this collateral's token, so the deposit would revert.");
+}
+/** Assembles liquidateBorrower's arguments and the position's state for one position id ("user:adapter:key"). */
+async function readLiquidationTarget(chainId, provider, ctx, positionId) {
+    const [user, poolAdapter, positionKey] = positionId.split(":");
+    const { data, assetType, assetToken } = await readLiquidationData(provider, poolAdapter, user, positionKey);
+    const pool = contract((0, contracts_1.getContractAddress)(chainId, "lendingpool"), (0, artifacts_1.getABI)("lendingpool"), provider);
+    const [vaultAdapter, collateralValue, debt, position] = await Promise.all([
+        findVaultAdapter(chainId, provider, assetToken, ctx.vaultToken),
+        contract(poolAdapter, ADAPTER_ABI, provider).getAssetValue(user, data),
+        pool.getPositionScaledDebt(poolAdapter, user, data),
+        pool.getPosition(poolAdapter, user, data),
+    ]);
+    return {
+        poolAdapter: ethers_1.ethers.getAddress(poolAdapter),
+        vaultAdapter,
+        user: ethers_1.ethers.getAddress(user),
+        data,
+        assetType,
+        assetToken,
+        isVaultToken: assetToken.toLowerCase() === ctx.vaultToken.toLowerCase(),
+        collateralValue,
+        debt,
+        isUnderLiquidation: position.isUnderLiquidation,
+        isInsured: position.isInsured,
+        liquidationStartTime: Number(position.liquidationStartTime),
+    };
+}
+async function quoteDy(provider, ctx, amount) {
+    if (amount <= ZERO)
+        return ZERO;
+    return contract(ctx.liquidityPool, CURVE_ABI, provider).get_dy(ctx.iIn, ctx.iOut, amount).catch(() => null);
+}
+/** Prices the liquidation with `split`, using the deployed Curve pool's get_dy rather than the vault's oracle price. */
+async function quoteLiquidation(provider, ctx, target, split) {
+    // poolDepositAsset mints from the vault adapter's own valuation, which may use a different oracle than the pool's.
+    const sharesFromCollateral = target.isVaultToken
+        ? decodeAmount(target.data)
+        : await contract(ctx.rwaVault, VAULT_ABI, provider).previewDeposit(await contract(target.vaultAdapter, VAULT_ADAPTER_ABI, provider).getAssetValue(target.data));
+    const totalVaultTokens = sharesFromCollateral + ctx.poolVaultTokens;
+    const swapAmount = (totalVaultTokens * split.swapBps) / BPS;
+    const [swapOut, maxSwapOut, spotOut, poolReserveOut] = await Promise.all([
+        quoteDy(provider, ctx, swapAmount),
+        quoteDy(provider, ctx, totalVaultTokens),
+        quoteDy(provider, ctx, WAD),
+        contract(ctx.liquidityPool, CURVE_ABI, provider).balances(ctx.iOut).catch(() => null),
+    ]);
+    let priceImpactBps = null;
+    if (swapOut !== null && spotOut && swapAmount > ZERO) {
+        const realised = (swapOut * WAD) / swapAmount;
+        priceImpactBps = realised >= spotOut ? ZERO : ((spotOut - realised) * BPS) / spotOut;
+    }
+    return {
+        split,
+        sharesFromCollateral,
+        totalVaultTokens,
+        swapAmount,
+        swapOut,
+        minSwapOut: ctx.slippage && swapAmount > ZERO ? ((ctx.slippage.pricePerShare * swapAmount) / ctx.slippage.oraclePrice) * (BPS - ctx.slippage.bps) / BPS : null,
+        shortfall: swapOut === null ? target.debt : swapOut >= target.debt ? ZERO : target.debt - swapOut,
+        coversDebt: swapOut !== null && swapOut >= target.debt,
+        badDebt: target.collateralValue < target.debt ? target.debt - target.collateralValue : ZERO,
+        maxSwapOut,
+        priceImpactBps,
+        poolReserveOut,
+    };
+}
+/**
+ * The smallest swap share whose get_dy still covers the debt plus `bufferBps`, with the rest given back to mint,
+ * burn and liquidity in their current proportion. get_dy grows with dx, so a binary search over BPS is sound.
+ */
+async function suggestSplit(provider, ctx, target, quote, bufferBps = BigInt(100)) {
+    if (quote.totalVaultTokens <= ZERO)
+        return null;
+    const required = (target.debt * (BPS + bufferBps)) / BPS;
+    const spread = (swapBps, projectedOut, bestEffort) => {
+        const rest = BPS - swapBps;
+        const others = ctx.split.mintBps + ctx.split.burnBps + ctx.split.liquidityBps;
+        const mintBps = others === ZERO ? ZERO : (rest * ctx.split.mintBps) / others;
+        const burnBps = others === ZERO ? ZERO : (rest * ctx.split.burnBps) / others;
+        return { mintBps, burnBps, swapBps, liquidityBps: rest - mintBps - burnBps, projectedOut, bestEffort };
+    };
+    const full = quote.maxSwapOut ?? (await quoteDy(provider, ctx, quote.totalVaultTokens));
+    if (full === null)
+        return null;
+    if (full < required)
+        return spread(BPS, full, true);
+    let low = ZERO;
+    let high = BPS;
+    let best = full;
+    while (low < high) {
+        const mid = (low + high) / BigInt(2);
+        const out = await quoteDy(provider, ctx, (quote.totalVaultTokens * mid) / BPS);
+        if (out !== null && out >= required) {
+            high = mid;
+            best = out;
+        }
+        else {
+            low = mid + BigInt(1);
+        }
+    }
+    return spread(low, best, false);
+}
+/** minSharesOut for the RWAVault deposit: previewDeposit less `slippageBps`. Zero when nothing is deposited. */
+const minSharesOut = (target, quote, slippageBps) => (target.isVaultToken ? ZERO : (quote.sharesFromCollateral * (BPS - slippageBps)) / BPS);
+exports.minSharesOut = minSharesOut;
+// StabilityPoolStorage is inherited first and the OpenZeppelin parents use namespaced storage, so liquidationSplit
+// takes slots 10 to 13. Checked against the live split before it is relied on.
+const SPLIT_SLOT = 10;
+/**
+ * Simulates liquidateBorrower from `sender` with the split overridden in storage (an eth_call state override), so a
+ * split change in the same batch is simulated rather than only checked. Returns null when the RPC or the storage
+ * layout cannot be used; otherwise the revert reason, or "" when it succeeds.
+ */
+async function simulateWithSplit(provider, ctx, sender, data, split) {
+    const send = provider.send?.bind(provider);
+    if (!send)
+        return null;
+    const slot = (i) => ethers_1.ethers.toBeHex(SPLIT_SLOT + i, 32);
+    try {
+        const live = await Promise.all(exports.SPLIT_KEYS.map((_, i) => provider.getStorage(ctx.stabilityPool, SPLIT_SLOT + i)));
+        if (exports.SPLIT_KEYS.some((k, i) => BigInt(live[i]) !== ctx.split[k]))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const stateDiff = Object.fromEntries(exports.SPLIT_KEYS.map((k, i) => [slot(i), ethers_1.ethers.toBeHex(split[k], 32)]));
+    try {
+        await send("eth_call", [{ from: sender, to: ctx.stabilityPool, data }, "latest", { [ctx.stabilityPool]: { stateDiff } }]);
+        return "";
+    }
+    catch (error) {
+        if (!ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+            return null;
+        return (error.data && attemptParse(error.data)) || error.reason || error.shortMessage;
+    }
+}
+function attemptParse(data) {
+    for (const key of ["stabilitypool", "lendingpool"]) {
+        try {
+            const e = new ethers_1.ethers.Interface((0, artifacts_1.getABI)(key)).parseError(data);
+            if (e)
+                return e.name === "Error" ? String(e.args[0]) : e.name;
+        }
+        catch { }
+    }
+    try {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["string"], ethers_1.ethers.dataSlice(data, 4))[0];
+    }
+    catch {
+        return null;
+    }
+}

package/dist/pools/stabilityPool/requestWithdraw.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestWithdraw = requestWithdraw;
 const _helpers_1 = require("./_helpers");
+const getContractAddress_1 = require("../../contracts/getContractAddress");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Queues a timelocked stability pool withdrawal.
  * @param chainId The chain id.
@@ -13,16 +15,14 @@ async function requestWithdraw(chainId, amount, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "stabilitypool");
     try {
         const stabilityPoolContract = await (0, _helpers_1.getStabilityPoolContract)(chainId, signer);
         const tx = await stabilityPoolContract.requestWithdraw(amount);
         const receipt = await tx.wait();
-        console.log(`Withdrawal request for ${amount} base units submitted successfully`);
-        console.log(`Transaction hash: ${receipt?.hash}`);
         return receipt;
     }
     catch (error) {
-        console.error("Error in requestWithdraw:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("stabilityPool.requestWithdraw", error, { chainId, address: contractAddress });
     }
 }

package/dist/pools/stabilityPool/withdrawFromStabilityPool.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const _helpers_1 = require("./_helpers");
+const getContractAddress_1 = require("../../contracts/getContractAddress");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Redeems deToken from the stability pool for rToken. When a withdraw timelock is active, `amount` must match the pending request.
  * @param chainId The chain id.
@@ -12,19 +14,17 @@ async function withdrawFromStabilityPool(chainId, amount, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "stabilitypool");
     try {
         const stabilityPoolContract = await (0, _helpers_1.getStabilityPoolContract)(chainId, signer);
         const tx = await stabilityPoolContract.withdraw(amount, {
             nonce: await signer.getNonce(),
         });
-        console.log(`Withdrawal transaction sent to Stability Pool:`, tx.hash);
         const receipt = await tx.wait();
-        console.log(`Withdrawn ${amount} base units from Stability Pool successfully:`, receipt?.hash);
         return receipt;
     }
     catch (error) {
-        console.error(`Error withdrawing from Stability Pool:`, error);
-        throw new Error(`Withdrawal from Stability Pool failed: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("stabilityPool.withdrawFromStabilityPool", error, { chainId, address: contractAddress });
     }
 }
 exports.default = withdrawFromStabilityPool;

package/dist/prices/computeStakingAPY.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStakingAPY = computeStakingAPY;
+const tokenPricesUSD_1 = require("./tokenPricesUSD");
+/** Simple staking APY = annualized emission value (RAAC x $) over staked value. */
+function computeStakingAPY(weeklyEmissionRAAC, stakedAmount, stakingTokenPriceUSD) {
+    const annualEmissionUSD = weeklyEmissionRAAC * 52 * (0, tokenPricesUSD_1.getTokenPriceUSD)("raac");
+    const stakedUSD = stakedAmount * stakingTokenPriceUSD;
+    if (stakedUSD <= 0)
+        return 0;
+    return (annualEmissionUSD / stakedUSD) * 100;
+}

package/dist/prices/getCurveLPPriceUSD.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurveLPPriceUSD = getCurveLPPriceUSD;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const resolveTokenInfo_1 = require("../contracts/resolveTokenInfo");
+const tokenPricesUSD_1 = require("./tokenPricesUSD");
+const CURVE_POOL_ABI = [
+    "function coins(uint256) view returns (address)",
+    "function balances(uint256) view returns (uint256)",
+    "function totalSupply() view returns (uint256)",
+];
+async function getCurveLPPriceUSD(chainId, token, provider) {
+    if (!provider) {
+        const rpcUrl = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    }
+    if (!token)
+        return null;
+    try {
+        const pool = new ethers_1.ethers.Contract(token, CURVE_POOL_ABI, provider);
+        const [c0, c1, b0, b1, supply] = await Promise.all([
+            pool.coins(0),
+            pool.coins(1),
+            pool.balances(0),
+            pool.balances(1),
+            pool.totalSupply(),
+        ]);
+        if (supply === 0n)
+            return 0;
+        const [info0, info1] = await Promise.all([
+            (0, resolveTokenInfo_1.resolveTokenInfo)(chainId, c0, provider),
+            (0, resolveTokenInfo_1.resolveTokenInfo)(chainId, c1, provider),
+        ]);
+        const p0 = (0, tokenPricesUSD_1.getTokenPriceUSD)(info0.symbol);
+        const p1 = (0, tokenPricesUSD_1.getTokenPriceUSD)(info1.symbol);
+        const tvl = Number(ethers_1.ethers.formatUnits(b0, info0.decimals)) * p0 + Number(ethers_1.ethers.formatUnits(b1, info1.decimals)) * p1;
+        return tvl / Number(ethers_1.ethers.formatEther(supply));
+    }
+    catch {
+        return null; // not a Curve pool
+    }
+}

package/dist/prices/getPrices.js

@@ -2,17 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPrices = void 0;
 const amount_1 = require("../utils/amount");
+const tokenPricesUSD_1 = require("./tokenPricesUSD");
 const ONE_USD = 10n ** BigInt(amount_1.WAD_DECIMALS);
-// TODO: fetch prices from coingecko / chainlink or similar.
+// TODO: fetch prices from coingecko / chainlink or similar; TOKEN_PRICES_USD
+// is a static placeholder map.
 /**
- * Returns the USD price of each token.
- * @returns The prices, each a USD price per whole token scaled by 1e18.
+ * Returns the static USD price of each known token.
+ * @returns The prices, each a USD price per whole token scaled by 1e18, keyed by lowercase symbol.
  */
 const getPrices = async () => {
-    return {
-        pmUSD: (0, amount_1.toScaled)(ONE_USD, amount_1.WAD_DECIMALS),
-        crvUSD: (0, amount_1.toScaled)(ONE_USD, amount_1.WAD_DECIMALS),
-        raac: (0, amount_1.toScaled)(ONE_USD, amount_1.WAD_DECIMALS),
-    };
+    const prices = {};
+    for (const [symbol, price] of Object.entries(tokenPricesUSD_1.TOKEN_PRICES_USD)) {
+        prices[symbol] = (0, amount_1.toScaled)(BigInt(price) * ONE_USD, amount_1.WAD_DECIMALS);
+    }
+    return prices;
 };
 exports.getPrices = getPrices;

package/dist/prices/getStakingTokenPriceUSD.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStakingTokenPriceUSD = getStakingTokenPriceUSD;
+const getCurveLPPriceUSD_1 = require("./getCurveLPPriceUSD");
+const getWrapperPriceUSD_1 = require("./getWrapperPriceUSD");
+const tokenPricesUSD_1 = require("./tokenPricesUSD");
+/**
+ * USD value of one unit of a gauge's staking token:
+ *  - wrapped gauges -> ERC4626 wrapper share price (underlying reserve token value),
+ *  - Curve-LP staking tokens -> LP price from pool reserves,
+ *  - otherwise -> static price by symbol.
+ */
+async function getStakingTokenPriceUSD(chainId, gauge, provider) {
+    if (gauge.wrapped) {
+        const wrapperAddr = gauge.wrapper ?? gauge.stakingToken;
+        if (wrapperAddr)
+            return (0, getWrapperPriceUSD_1.getWrapperPriceUSD)(chainId, wrapperAddr, gauge.underlyingSymbol ?? "pmusd", provider);
+    }
+    if (gauge.stakingToken) {
+        const lp = await (0, getCurveLPPriceUSD_1.getCurveLPPriceUSD)(chainId, gauge.stakingToken, provider);
+        if (lp != null)
+            return lp;
+    }
+    return (0, tokenPricesUSD_1.getTokenPriceUSD)(gauge.stakingTokenSymbol);
+}

package/dist/prices/getWrapperPriceUSD.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWrapperPriceUSD = getWrapperPriceUSD;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const tokenPricesUSD_1 = require("./tokenPricesUSD");
+const ERC4626_CONVERT_ABI = ["function convertToAssets(uint256) view returns (uint256)"];
+/**
+ * USD value of one ERC4626 wrapper share = assets-per-share x underlying price
+ * (e.g. a wrapped RToken share -> its reserve token per share x that token's price).
+ */
+async function getWrapperPriceUSD(chainId, wrapper, underlyingSymbol = "pmusd", provider) {
+    if (!provider) {
+        const rpcUrl = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    }
+    if (!wrapper)
+        return 0;
+    try {
+        const w = new ethers_1.ethers.Contract(wrapper, ERC4626_CONVERT_ABI, provider);
+        const assetsPerShare = Number(ethers_1.ethers.formatEther(await w.convertToAssets(ethers_1.ethers.parseEther("1"))));
+        // Falls back to pmUSD ($1) when the underlying symbol isn't priced -
+        // most wrapped RTokens are 1:1 with their reserve.
+        const underlyingPrice = (0, tokenPricesUSD_1.getTokenPriceUSD)(underlyingSymbol) || (0, tokenPricesUSD_1.getTokenPriceUSD)("pmusd");
+        return assetsPerShare * underlyingPrice;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/prices/tokenPricesUSD.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_PRICES_USD = void 0;
+exports.getTokenPriceUSD = getTokenPriceUSD;
+/**
+ * Canonical static USD price per whole token, by lowercase symbol. Testnet
+ * placeholder values - swap for a real oracle/feed in production.
+ */
+exports.TOKEN_PRICES_USD = {
+    raac: 5,
+    pmusd: 1,
+    crvusd: 1, // same token the chain config's asset registry displays as pmUSD
+    ireet: 1, // RWA index token (NAV ~ 0.995, rounded to 1 for display)
+    usdc: 1,
+    leraac: 5,
+};
+/** Static USD price for a token symbol (0 if unknown). */
+function getTokenPriceUSD(symbol) {
+    if (!symbol)
+        return 0;
+    return exports.TOKEN_PRICES_USD[symbol.toLowerCase()] ?? 0;
+}