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

package/dist/types/utils/contracts.d.ts

@@ -130,6 +130,14 @@ export declare const getConfigs: () => {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -166,6 +174,13 @@ export declare const getConfigs: () => {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;
@@ -390,6 +405,14 @@ declare const _default: {
                 };
             };
             proposals: any[];
+            psm: {
+                "rpsm-susds": {
+                    id: string;
+                    name: string;
+                    contract: string;
+                    rateProvider: string;
+                };
+            };
             pools: {
                 stabilitypool: {
                     id: string;
@@ -426,6 +449,13 @@ declare const _default: {
                     decimals: number;
                     contract: string;
                 };
+                susds: {
+                    id: string;
+                    name: string;
+                    symbol: string;
+                    decimals: number;
+                    contract: string;
+                };
                 xpm: {
                     id: string;
                     name: string;
@@ -514,3 +544,5 @@ declare const _default: {
     };
 };
 export default _default;
+/** Whether a config address is set and deployed: a valid, non-zero address. */
+export declare const isDeployed: (address: string | null | undefined) => address is string;

package/dist/types/utils/errorDecoder.d.ts

@@ -1,37 +1,38 @@
-interface GeneratedErrorInfo {
+import { Interface, InterfaceAbi } from "ethers";
+export interface DecodedRevert {
     name: string;
-    signature: string;
-    message: string;
-    contract?: string;
-    inputs?: Array<{
-        name: string;
-        type: string;
-        internalType: string;
-    }>;
+    /** Argument values by name; unnamed/tuple arguments fall back to their positional index as a string key. */
+    args: Record<string, unknown>;
 }
 /**
- * Returns detailed information about the error encoded in the given data blob.
+ * Decodes revert data against a specific contract's ABI, recovering the error's
+ * argument values, not just its name, as long as the caller already knows
+ * which contract it called (see contracts/findContract.ts).
+ *
+ * @param abi The ABI of the contract that was called.
  * @param data The revert data returned by the EVM (e.g., error.data).
+ * @returns The error name and its decoded arguments, or null if `data` doesn't match any error in `abi`.
  */
-export declare function getErrorInfo(data?: string): GeneratedErrorInfo | null;
+export declare function decodeRevertWithAbi(abi: Interface | InterfaceAbi, data?: string): DecodedRevert | null;
 /**
- * Returns only the error name, or null if it cannot be decoded.
- */
-export declare function decodeErrorName(data?: string): string | null;
-/**
- * Returns the custom error message, or null if it cannot be decoded.
- */
-export declare function decodeErrorMessage(data?: string): string | null;
-/**
- * Builds a user-friendly error prefix with decoded error name (if available).
- * Usage example:
- *   const msg = attachDecodedError("Deposit failed", caughtError);
+ * Decodes revert data against every custom error in {@link ABIS}. This is the
+ * fallback for a revert thrown by a contract other than the one called: e.g.
+ * LendingPool.deposit bubbling up crvUSD's `ERC20InsufficientAllowance`, which
+ * LendingPool's own ABI does not declare. When two contracts declare the same
+ * selector, the first one in `ABIS` order wins: a shared selector means a
+ * shared signature, so only the argument names can differ.
+ *
+ * @param data The revert data returned by the EVM (e.g., error.data).
+ * @returns The error name and its decoded arguments, or null if no known contract declares that selector.
  */
-export declare function attachDecodedError(prefix: string, error: any): string;
+export declare function decodeRevertWithAllAbis(data?: string): DecodedRevert | null;
 /**
- * Builds a user-friendly error message with custom error description (if available).
- * Usage example:
- *   const msg = attachDecodedErrorMessage("Deposit failed", caughtError);
+ * Names the custom error behind a bare 4-byte selector, for when a wallet or
+ * client surfaced the selector but not the full revert data (so the arguments
+ * cannot be decoded). Looks in `abi` first, then in every known ABI.
+ *
+ * @param selector The 4-byte error selector, e.g. "0x79db4619".
+ * @param abi The ABI of the contract that was called, when known.
+ * @returns The error name, or null if no known contract declares that selector.
  */
-export declare function attachDecodedErrorMessage(prefix: string, error: any): string;
-export {};
+export declare function errorNameForSelector(selector: string, abi?: Interface | InterfaceAbi): string | null;

package/dist/types/utils/rpcError.d.ts

@@ -0,0 +1,52 @@
+import { ChainId } from "../configs/chains";
+export type RpcErrorCode = "USER_REJECTED" | "CONTRACT_REVERT" | "INSUFFICIENT_FUNDS" | "NETWORK" | "UNKNOWN";
+export interface RpcErrorContract {
+    id: string;
+    name: string;
+    address: string;
+}
+export interface RpcErrorParams {
+    code: RpcErrorCode;
+    action: string;
+    message: string;
+    contract?: RpcErrorContract;
+    errorName?: string;
+    selector?: string;
+    args?: Record<string, unknown>;
+    cause: unknown;
+}
+/**
+ * The one error type every `rpc` function throws. Replaces the ~5 inconsistent
+ * catch-block shapes in the codebase today (plain `new Error(\`Failed to…\`)`
+ * rewraps, ad hoc decoder string concatenation, raw rethrows, no handling at
+ * all) with one structure a consumer can actually branch on: skip
+ * `USER_REJECTED` without a toast, tag Sentry with `code`/`contract`/`errorName`
+ * instead of a free-text string.
+ */
+export declare class RpcError extends Error {
+    code: RpcErrorCode;
+    action: string;
+    contract?: RpcErrorContract;
+    errorName?: string;
+    selector?: string;
+    args?: Record<string, unknown>;
+    cause: unknown;
+    constructor(params: RpcErrorParams);
+}
+export interface ResolveContext {
+    chainId: ChainId;
+    /** The address the failed call was sent to, when the caller has it on hand. */
+    address?: string;
+}
+/**
+ * Builds an {@link RpcError} from whatever ethers, a wallet, or the network
+ * threw. Every `rpc` function's catch block calls this instead of hand-rolling
+ * its own rewrap.
+ *
+ * @param action - What was being attempted, e.g. "lendingPool.deposit".
+ * @param error - The error caught.
+ * @param resolve - The chain and, when known, the address that was called —
+ *   lets the error be decoded against that contract's own ABI instead of a
+ *   selector-only guess, and names the contract on the result.
+ */
+export declare function toRpcError(action: string, error: unknown, resolve?: ResolveContext): RpcError;

package/dist/user/_helpers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settled = void 0;
+exports.requireUsd = requireUsd;
+const amount_1 = require("../utils/amount");
+/** Settles one read into a {@link Section}: never rejects, so reads awaited together fail independently. */
+const settled = (read) => read.then((data) => ({ data, error: null }), (reason) => ({ data: null, error: reason instanceof Error ? reason : new Error(String(reason)) }));
+exports.settled = settled;
+/**
+ * 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.
+ */
+function requireUsd(prices, amount, token) {
+    if (amount.symbol === undefined)
+        throw new Error(`No USD price for ${token}: it has no symbol in the chain config's assets`);
+    const price = prices[amount.symbol.toLowerCase()];
+    if (typeof price !== "number" || !Number.isFinite(price))
+        throw new Error(`No USD price for ${amount.symbol}`);
+    return (0, amount_1.toNumber)(amount) * price;
+}

package/dist/user/computeEffectiveReturn.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeEffectiveReturn = computeEffectiveReturn;
+/**
+ * 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.
+ */
+function computeEffectiveReturn({ legs, collateralUsd, idleUsd = 0 }) {
+    const withIncome = legs.map((leg) => {
+        const income = leg.valueUsd * leg.rate;
+        return { ...leg, income1y: leg.kind === "cost" ? -income : income };
+    });
+    const netIncome1y = withIncome.reduce((sum, leg) => sum + leg.income1y, 0);
+    const debtUsd = legs.filter((leg) => leg.kind === "cost").reduce((sum, leg) => sum + leg.valueUsd, 0);
+    const capitalUsd = legs.filter((leg) => leg.countsAsCapital).reduce((sum, leg) => sum + leg.valueUsd, 0);
+    const netCapitalUsd = collateralUsd + capitalUsd + idleUsd - debtUsd;
+    return {
+        netIncome1y,
+        onDebt: debtUsd > 0 ? netIncome1y / debtUsd : null,
+        onNetCapital: netCapitalUsd > 0 ? netIncome1y / netCapitalUsd : null,
+        debtUsd,
+        netCapitalUsd,
+        legs: withIncome,
+    };
+}

package/dist/user/getUserClaimables.js

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

package/dist/user/getUserCollateral.js

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

package/dist/user/getUserDebt.js

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

package/dist/user/getUserFarming.js

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

package/dist/user/getUserGovernance.js

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