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

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

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

package/dist/contracts/curve/common/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,27 @@
+"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("./addLiquidity"), exports);
+__exportStar(require("./calcTokenAmount"), exports);
+__exportStar(require("./calcWithdrawOneCoin"), exports);
+__exportStar(require("./exchange"), exports);
+__exportStar(require("./getDy"), exports);
+__exportStar(require("./getPools"), exports);
+__exportStar(require("./getPoolInterface"), exports);
+__exportStar(require("./getPoolState"), exports);
+__exportStar(require("./getVirtualPrice"), exports);
+__exportStar(require("./removeLiquidity"), exports);
+__exportStar(require("./removeLiquidityOneCoin"), exports);

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLiquidity = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Burns LP tokens for every coin of a Curve pool in proportion to its balances.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param lpAmount - LP tokens to burn (18 decimals).
+ * @param minAmounts - The least of each coin to accept, in pool order and each coin's base units.
+ * @param receiver - Who receives the coins.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const removeLiquidity = async (chainId, poolAddressOrId, lpAmount, minAmounts, receiver, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getCurvePoolFlavourContract)(chainId, poolAddressOrId, signer);
+    (0, _helpers_1.assertCoinCount)(entry, minAmounts, "removeLiquidity");
+    try {
+        const tx = await contract.remove_liquidity(lpAmount, minAmounts, receiver);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("curve.removeLiquidity", error, { chainId, address: entry.contract });
+    }
+};
+exports.removeLiquidity = removeLiquidity;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLiquidityOneCoin = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Burns LP tokens for a single coin of a Curve pool.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param lpAmount - LP tokens to burn (18 decimals).
+ * @param i - Index of the coin to receive, in pool order.
+ * @param minAmount - The least of coin `i` to accept, in its base units. See `calcWithdrawOneCoin`.
+ * @param receiver - Who receives the coin.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const removeLiquidityOneCoin = async (chainId, poolAddressOrId, lpAmount, i, minAmount, receiver, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getCurvePoolFlavourContract)(chainId, poolAddressOrId, signer);
+    (0, _helpers_1.assertCoinIndex)(entry, i);
+    try {
+        const tx = await contract.remove_liquidity_one_coin(lpAmount, i, minAmount, receiver);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("curve.removeLiquidityOneCoin", error, { chainId, address: entry.contract });
+    }
+};
+exports.removeLiquidityOneCoin = removeLiquidityOneCoin;

package/dist/contracts/faucet/claim.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claim = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
+const FAUCET_CLAIM_ABI = [
+    "function claim(address token, uint256 amount)",
+    "function claimMultiple(address[] tokens, uint256[] amounts)",
+];
+/**
+ * Claims testnet tokens from the faucet: one `claim` for a single token, one `claimMultiple` for several.
+ *
+ * @param chainId - The chain/network to use; only chains with a `faucet` contract in their config.
+ * @param claims - The tokens and amounts to claim.
+ * @param signer - The signer sending the transaction; the tokens go to its address.
+ * @returns The mined transaction receipt.
+ * @throws If the chain has no faucet, `claims` is empty, or the transaction fails.
+ */
+const claim = async (chainId, claims, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    if (claims.length === 0)
+        throw new Error("Nothing to claim");
+    const address = (0, contracts_1.getContractAddress)(chainId, "faucet");
+    try {
+        const faucet = new ethers_1.ethers.Contract(address, FAUCET_CLAIM_ABI, signer);
+        const tx = claims.length === 1
+            ? await faucet.claim(claims[0].token, claims[0].amount)
+            : await faucet.claimMultiple(claims.map(({ token }) => token), claims.map(({ amount }) => amount));
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("faucet.claim", error, { chainId, address });
+    }
+};
+exports.claim = claim;

package/dist/contracts/faucet/getState.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getState = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const amount_1 = require("../../utils/amount");
+const artifacts_1 = require("../../utils/artifacts");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
+const ERC20 = ["function symbol() view returns (string)", "function decimals() view returns (uint8)", "function balanceOf(address) view returns (uint256)"];
+/**
+ * Reads the testnet faucet: its owner, whether it is paused, and every token it gives out with its balance and per-claim cap.
+ * The faucet has no deposit function; it is topped up with a plain ERC20 transfer.
+ *
+ * @param chainId - The chain/network to use; only chains with a `faucet` contract in their config (Sepolia).
+ * @param provider - Optional ethers.js Provider instance.
+ */
+const getState = async (chainId, provider) => {
+    if (!provider)
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    const address = (0, contracts_1.getContractAddress)(chainId, "faucet");
+    const faucet = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("faucet"), provider);
+    try {
+        const [owner, paused, list] = await Promise.all([faucet.owner(), faucet.paused(), faucet.allTokens()]);
+        const tokens = await Promise.all(list.map(async (token) => {
+            const erc20 = new ethers_1.ethers.Contract(token, ERC20, provider);
+            const [symbol, decimals, balance, cap, approved] = await Promise.all([
+                erc20.symbol(),
+                erc20.decimals().then(Number),
+                erc20.balanceOf(address),
+                faucet.tokenCap(token),
+                faucet.approvedToken(token),
+            ]);
+            return { address: ethers_1.ethers.getAddress(token), symbol, decimals, balance: (0, amount_1.toAmount)(balance, decimals, symbol), cap: (0, amount_1.toAmount)(cap, decimals, symbol), approved };
+        }));
+        return { address: ethers_1.ethers.getAddress(address), owner, paused, tokens };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("faucet.getState", error, { chainId, address });
+    }
+};
+exports.getState = getState;

package/dist/contracts/faucet/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("./claim"), exports);
+__exportStar(require("./getState"), exports);

package/dist/contracts/feeCollector/claimRewardFromPool.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
 async function claimRewardFromPool(chainId, poolAddress, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
@@ -17,8 +18,7 @@ async function claimRewardFromPool(chainId, poolAddress, signer) {
         // console.log(`Claimed reward from pool: ${poolAddress}`);
     }
     catch (error) {
-        console.error("Error FEECOLLECTOR claiming reward from pool:", error);
-        throw new Error(`Failed to claim reward from pool: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("feeCollector.claimRewardFromPool", error, { chainId });
     }
 }
 exports.default = claimRewardFromPool;

package/dist/contracts/feeCollector/getState.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_FEE_TYPES = exports.FEE_TARGETS = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+/** The six places a fee type splits into, as FeeCollector names them. */
+exports.FEE_TARGETS = ["TREASURY", "REPAIR_FUND", "BURN", "VERAAC", "RAAC_CORP", "OTHER"];
+/** Fee type names used across the protocol; others show as their raw bytes32. */
+exports.KNOWN_FEE_TYPES = [
+    "LENDING_POOL_YIELD",
+    "RAAC_NFT_SALE",
+    "ROYALTY_FEE",
+    "SWAP_FEE",
+    "INSURANCE_FEE",
+    "PROTOCOL_FEE",
+    "LENDING_FEE",
+    "MINT_FEE",
+    "RWA_INDEX_TOKEN_SWAP_FEE",
+    "RWA_INDEX_TOKEN_LIQUIDITY_REWARDS",
+];
+const TARGET_GETTERS = {
+    TREASURY: "treasuryAddress",
+    REPAIR_FUND: "repairFundAddress",
+    BURN: "burnAddress",
+    VERAAC: "veRAACAddress",
+    RAAC_CORP: "raacCorpAddress",
+    OTHER: "otherAddress",
+};
+const AMOUNT_FIELDS = {
+    TREASURY: "treasuryAmount",
+    REPAIR_FUND: "repairFundAmount",
+    BURN: "burnAmount",
+    VERAAC: "veRAACTokenAmount",
+    RAAC_CORP: "raacCorpAmount",
+    OTHER: "otherAmount",
+};
+const SHARE_FIELDS = {
+    TREASURY: "treasuryShare",
+    REPAIR_FUND: "repairFundShare",
+    BURN: "burnShare",
+    VERAAC: "veRAACTokenShare",
+    RAAC_CORP: "raacCorpShare",
+    OTHER: "otherShare",
+};
+/**
+ * Reads the FeeCollector: pause state, targets, fee types and their splits, supported tokens, and what is still owed
+ * per token, fee type and target. Walks `supportedTokens(i)` until the index reverts.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "feecollector");
+    try {
+        const fc = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("feecollector"), provider);
+        const [paused, targetList, rawTypes] = await Promise.all([
+            fc.paused(),
+            Promise.all(exports.FEE_TARGETS.map((t) => fc[TARGET_GETTERS[t]]())),
+            fc.getFeeTypes(),
+        ]);
+        const names = new Map(exports.KNOWN_FEE_TYPES.map((n) => [ethers_1.ethers.id(n), n]));
+        const feeTypes = rawTypes.map((t) => ({
+            id: t.feeType,
+            name: names.get(t.feeType) ?? null,
+            shares: Object.fromEntries(exports.FEE_TARGETS.map((target) => [target, BigInt(t[SHARE_FIELDS[target]])])),
+        }));
+        const list = [];
+        for (let i = 0; i < 200; i++) {
+            try {
+                list.push(ethers_1.ethers.getAddress(await fc.supportedTokens(i)));
+            }
+            catch (error) {
+                if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                    break;
+                throw error;
+            }
+        }
+        const tokens = await Promise.all(list.map(async (token) => {
+            const erc20 = new ethers_1.ethers.Contract(token, ["function symbol() view returns (string)", "function decimals() view returns (uint8)"], provider);
+            const [symbol, decimals] = await Promise.all([erc20.symbol().catch(() => "?"), erc20.decimals().then(Number).catch(() => 18)]);
+            return { address: token, symbol, decimals };
+        }));
+        const pairs = tokens.flatMap((token) => feeTypes.map((feeType) => ({ token, feeType })));
+        const collected = (await Promise.all(pairs.map(async ({ token, feeType }) => {
+            const c = await fc.getCollectedFees(token.address, feeType.id);
+            return {
+                token: token.address,
+                feeType: feeType.id,
+                amounts: Object.fromEntries(exports.FEE_TARGETS.map((t) => [t, (0, amount_1.toAmount)(c[AMOUNT_FIELDS[t]], token.decimals, token.symbol)])),
+            };
+        }))).filter((c) => exports.FEE_TARGETS.some((t) => c.amounts[t].value > BigInt(0)));
+        return { paused, targets: Object.fromEntries(exports.FEE_TARGETS.map((t, i) => [t, targetList[i]])), feeTypes, tokens, collected };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("feeCollector.getState", error, { chainId, address });
+    }
+}
+exports.default = getState;

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", "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

@@ -30,6 +30,8 @@ const getContractAddress = (chainId, contractName) => {
         "nfts",
         "lockers",
         "zap",
+        "psm",
+        "curve",
     ];
     let address = null;
     for (const key of lookupKeys) {
@@ -45,8 +47,6 @@ const getContractAddress = (chainId, contractName) => {
         }
     }
     if (!address) {
-        console.error(`Contract address not found for ${normalizedContractName} on chain ${chainId}`);
-        console.error("Available contracts:", Object.keys(config.contracts));
         throw new Error(`Contract ${normalizedContractName} not found for chain ID: ${chainId}`);
     }
     if (address.toLowerCase() === ZERO_ADDRESS) {

package/dist/contracts/getRoles.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roleId = roleId;
+const ethers_1 = require("ethers");
+const rpcError_1 = require("../utils/rpcError");
+const ACCESS_ABI = ["function hasRole(bytes32 role, address account) view returns (bool)"];
+/** OpenZeppelin role ids: DEFAULT_ADMIN_ROLE is zero, every other role is the keccak of its name. */
+function roleId(role) {
+    if (/^0x[0-9a-fA-F]{64}$/.test(role))
+        return role;
+    return role === "DEFAULT_ADMIN_ROLE" ? ethers_1.ethers.ZeroHash : ethers_1.ethers.id(role);
+}
+/**
+ * Which of an AccessControl contract's roles each account holds, e.g. to show what a Safe and a wallet may do.
+ * @param chainId The chain id, for error context.
+ * @param contractAddress The AccessControl contract.
+ * @param roles Role names ("GUARDIAN_ROLE", "DEFAULT_ADMIN_ROLE") or raw 32-byte ids.
+ * @param accounts The accounts to check.
+ * @param provider The provider to read with.
+ * @returns Keyed by lowercased account address, then by role as passed in.
+ */
+async function getRoles(chainId, contractAddress, roles, accounts, provider) {
+    try {
+        const contract = new ethers_1.ethers.Contract(contractAddress, ACCESS_ABI, provider);
+        const entries = await Promise.all(accounts.map(async (account) => {
+            const held = await Promise.all(roles.map((role) => contract.hasRole(roleId(role), account)));
+            return [account.toLowerCase(), Object.fromEntries(roles.map((role, i) => [role, held[i]]))];
+        }));
+        return Object.fromEntries(entries);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("contracts.getRoles", error, { chainId, address: contractAddress });
+    }
+}
+exports.default = getRoles;

package/dist/contracts/getTokenMetadata.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenMetadata = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const rpcError_1 = require("../utils/rpcError");
+const ERC20_METADATA_ABI = ["function symbol() view returns (string)", "function decimals() view returns (uint8)"];
+/**
+ * Reads `symbol()`/`decimals()` directly from an arbitrary ERC20 token address -
+ * for tokens not in the chain config's asset registry (e.g. a veRAAC reward
+ * token or a gauge's reward token), where there's no registry entry to look
+ * up instead.
+ */
+const getTokenMetadata = async (chainId, address, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    try {
+        const contract = new ethers_1.ethers.Contract(address, ERC20_METADATA_ABI, provider);
+        const [symbol, decimals] = await Promise.all([contract.symbol(), contract.decimals()]);
+        return { symbol, decimals: Number(decimals) };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("contracts.getTokenMetadata", error, { chainId, address });
+    }
+};
+exports.getTokenMetadata = getTokenMetadata;

package/dist/contracts/governance/_helpers.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toGovernanceTxError = exports.requireAddress = void 0;
+exports.requireAddress = void 0;
 const ethers_1 = require("ethers");
-const errorDecoder_1 = require("../../utils/errorDecoder");
 /**
  * Validates and checksums a contract address passed by the caller.
  *
@@ -17,23 +16,3 @@ const requireAddress = (address, name) => {
     return ethers_1.ethers.getAddress(address);
 };
 exports.requireAddress = requireAddress;
-/**
- * Wraps a failed write so the message says what failed while the original
- * error stays reachable: its code (a wallet rejection is ACTION_REJECTED), its
- * revert data and the decoded custom error name.
- *
- * @param prefix - What was being attempted, e.g. "Failed to cast vote".
- * @param error - The error ethers threw.
- * @returns An Error carrying `code`, `data`, `errorName` and `cause`.
- */
-const toGovernanceTxError = (prefix, error) => {
-    const data = error?.data ?? error?.error?.data ?? error?.info?.error?.data;
-    const errorName = error?.revert?.name ?? (0, errorDecoder_1.decodeErrorName)(typeof data === "string" ? data : undefined) ?? undefined;
-    const wrapped = new Error(`${(0, errorDecoder_1.attachDecodedError)(prefix, error)}: ${error?.shortMessage ?? error?.message ?? String(error)}`);
-    wrapped.code = error?.code;
-    wrapped.data = typeof data === "string" ? data : undefined;
-    wrapped.errorName = errorName;
-    wrapped.cause = error;
-    return wrapped;
-};
-exports.toGovernanceTxError = toGovernanceTxError;

package/dist/contracts/governance/distributor/claimAll.js

@@ -4,7 +4,7 @@ exports.claimAll = void 0;
 const ethers_1 = require("ethers");
 const artifacts_1 = require("../../../utils/artifacts");
 const _helpers_1 = require("../gaugeSystems/_helpers");
-const _helpers_2 = require("../_helpers");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Claims rewards for the caller on several gauges. Each gauge must be active.
  *
@@ -26,7 +26,7 @@ const claimAll = async (chainId, gaugeSystem, gaugeAddressesOrIds, signer) => {
         return tx;
     }
     catch (error) {
-        throw (0, _helpers_2.toGovernanceTxError)("Failed to claim all", error);
+        throw (0, rpcError_1.toRpcError)("Failed to claim all", error, { chainId, address });
     }
 };
 exports.claimAll = claimAll;